/*
Copyright (c) [2019年5月1日] [吴超]
[MBT_Studio] is licensed under Mulan PSL v2.
You can use this software according to the terms and conditions of the Mulan PSL v2.
You may obtain a copy of Mulan PSL v2 at:
		 http://license.coscl.org.cn/MulanPSL2
THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
See the Mulan PSL v2 for more details.
*/
#include "ui节点创建菜单.h"

#include "节点类型构建/构建时间轴编辑节点.h"
#include "节点类型构建/构建视频图像节点.h"
#include "节点类型构建/构建几何节点.h"
#include "节点类型构建/构建物理节点.h"
#include "节点类型构建/构建逻辑节点.h"
#include "节点类型构建/构建数据节点.h"
#include "节点类型构建/构建调试节点.h"
#include "节点类型构建/物体节点构建.h"
#include "节点类型构建/构建容器节点.h"
#include "节点类型构建/构建场景节点.h"
#include "节点类型构建/构建计算节点.h"
#include "节点类型构建/构建脚本节点.h"

#include "../节点构建.h"
#include "框架/工作区/节点操作.h"

#include "A_引擎/引擎.h"

#include <节点/逻辑/单节点脚本.h>
#include <节点/socket_utils.h>




static S_UI创建环境* g当前UI环境 = 0;

static fp_节点创建视口回调 fun_节点视口回调 = 0;
static fp_节点添加到视口回调 fun_创建多节点添加到视口回调 = 0;



void f_init_物体节点创建_绑定视口回调(fp_节点创建视口回调 fun, fp_节点添加到视口回调 多节点创建回调) {
	fun_节点视口回调 = fun;
	fun_创建多节点添加到视口回调 = 多节点创建回调;


	C_节点面板::g节点面板构建函数["射线拾取节点"] = f_节点构建_射线物体拾取;
	C_节点面板::g节点面板构建函数["范围拾取节点"] = f_节点构建_范围拾取;
	C_节点面板::g节点面板构建函数["帧时间节点"] = f_节点构建_帧时间;
	C_节点面板::g节点面板重置函数["帧时间节点"] = f_节点重置_帧时间;
	C_节点面板::g节点面板构建函数["OpenVDB网格节点"] = f_节点构建_OpenVDB网格;
	C_节点面板::g节点面板重置函数["OpenVDB网格节点"] = f_节点重置_OpenVDB网格;


	//================================ 网格 =========================================
	C_节点面板::g节点面板构建函数["几何预览节点"] = f_节点构建_几何预览;
	C_节点面板::g节点面板重置函数["几何预览节点"] = f_节点重置_几何预览;

	C_节点面板::g节点面板构建函数["平面网格节点"] = f_节点构建_几何平面;
	C_节点面板::g节点面板重置函数["平面网格节点"] = f_节点重置_几何平面;
	C_节点面板::g节点面板构建函数["球体网格生成节点"] = f_节点构建_几何球体;
	C_节点面板::g节点面板重置函数["球体网格生成节点"] = f_节点重置_几何球体;
	C_节点面板::g节点面板构建函数["矩形网格生成节点"] = f_节点构建_几何矩形;
	C_节点面板::g节点面板重置函数["矩形网格生成节点"] = f_节点重置_几何矩形;
	C_节点面板::g节点面板构建函数["线框立方体节点"] = f_节点构建_线框立方体;
	C_节点面板::g节点面板重置函数["线框立方体节点"] = f_节点重置_线框立方体;

	C_节点面板::g节点面板构建函数["网格体素节点"] = f_节点构建_网格体素;
	C_节点面板::g节点面板构建函数["网格采样节点"] = f_节点构建_网格采样;
	C_节点面板::g节点面板构建函数["网格属性节点"] = f_节点构建_网格属性;
	C_节点面板::g节点面板重置函数["网格属性节点"] = f_节点重置_网格属性;
	C_节点面板::g节点面板构建函数[DEF_网格选择节点] = f_节点构建_网格选择;
	C_节点面板::g节点面板重置函数[DEF_网格选择节点] = f_节点重置_网格选择;

	C_节点面板::g节点面板构建函数[DEF_面朝向节点] = f_节点构建_面朝向;
	C_节点面板::g节点面板重置函数[DEF_面朝向节点] = f_节点重置_面朝向;


	C_节点面板::g节点面板构建函数[DEF_网格节点] = f_节点构建_几何网格;
	C_节点面板::g节点面板重置函数[DEF_网格节点] = f_节点重置_几何网格;

	C_节点面板::g节点面板构建函数[DEF_几何节点] = f_节点构建_几何;
	C_节点面板::g节点面板重置函数[DEF_几何节点] = f_节点重置_几何;

	C_节点面板::g节点面板构建函数[DEF_几何ID节点] = f_节点构建_几何ID;
	C_节点面板::g节点面板重置函数[DEF_几何ID节点] = f_节点重置_几何ID;

	C_节点面板::g节点面板构建函数[DEF_当前多边形节点] = f_节点构建_当前多边形;
	C_节点面板::g节点面板重置函数[DEF_当前多边形节点] = f_节点重置_当前多边形;

	C_节点面板::g节点面板构建函数[DEF_基本多边形节点] = f_节点构建_基本多边形;
	C_节点面板::g节点面板重置函数[DEF_基本多边形节点] = f_节点重置_基本多边形;
	C_节点面板::g节点面板构建函数[DEF_多边形边节点] = f_节点构建_多边形边;
	C_节点面板::g节点面板重置函数[DEF_多边形边节点] = f_节点重置_多边形边;
	C_节点面板::g节点面板构建函数[DEF_添加纹理坐标节点] = f_节点构建_添加多边形纹理坐标;
	C_节点面板::g节点面板重置函数[DEF_添加纹理坐标节点] = f_节点重置_添加多边形纹理坐标;

	C_节点面板::g节点面板构建函数[DEF_添加多边形元素节点] = f_节点构建_添加多边形元素;
	C_节点面板::g节点面板重置函数[DEF_添加多边形元素节点] = f_节点重置_添加多边形元素;

	C_节点面板::g节点面板构建函数[DEF_多边形面节点] = f_节点构建_多边形面;
	C_节点面板::g节点面板重置函数[DEF_多边形面节点] = f_节点重置_多边形面;
	C_节点面板::g节点面板构建函数[DEF_多边形节点] = f_节点构建_多边形;
	C_节点面板::g节点面板重置函数[DEF_多边形节点] = f_节点重置_多边形;
	C_节点面板::g节点面板构建函数[DEF_多边形添加顶点节点] = f_节点构建_多边形添加顶点;
	C_节点面板::g节点面板重置函数[DEF_多边形添加顶点节点] = f_节点重置_多边形添加顶点;
	C_节点面板::g节点面板构建函数[DEF_多边形删除顶点节点] = f_节点构建_多边形删除顶点;
	C_节点面板::g节点面板重置函数[DEF_多边形删除顶点节点] = f_节点重置_多边形删除顶点;
	C_节点面板::g节点面板构建函数[DEF_多边形桥接节点] = f_节点构建_多边形桥接节点;
	C_节点面板::g节点面板重置函数[DEF_多边形桥接节点] = f_节点重置_多边形桥接节点;
	C_节点面板::g节点面板构建函数[DEF_点桥接节点] = f_节点构建_点桥接节点;
	C_节点面板::g节点面板重置函数[DEF_点桥接节点] = f_节点重置_点桥接节点;

	C_节点面板::g节点面板构建函数[DEF_多边形边实体化节点] = f_节点构建_多边形边实体化节点;
	C_节点面板::g节点面板重置函数[DEF_多边形边实体化节点] = f_节点重置_多边形边实体化节点;

	C_节点面板::g节点面板构建函数[DEF_多边形边采样节点] = f_节点构建_多边形边采样节点;
	C_节点面板::g节点面板重置函数[DEF_多边形边采样节点] = f_节点重置_多边形边采样节点;

	C_节点面板::g节点面板构建函数[DEF_多边形索引节点] = f_节点构建_取多边形索引节点;
	C_节点面板::g节点面板重置函数[DEF_多边形索引节点] = f_节点重置_取多边形索引节点;

	C_节点面板::g节点面板构建函数[DEF_多边形复制节点] = f_节点构建_多边形复制节点;
	C_节点面板::g节点面板重置函数[DEF_多边形复制节点] = f_节点重置_多边形复制节点;

	C_节点面板::g节点面板构建函数[DEF_多边形拷贝节点] = f_节点构建_多边形拷贝节点;
	C_节点面板::g节点面板重置函数[DEF_多边形拷贝节点] = f_节点重置_多边形拷贝节点;

	C_节点面板::g节点面板构建函数[DEF_多边形变换节点] = f_节点构建_多边形变换节点;
	C_节点面板::g节点面板重置函数[DEF_多边形变换节点] = f_节点重置_多边形变换节点;

	C_节点面板::g节点面板构建函数[DEF_取多边形面属性节点] = f_节点构建_取多边形面属性节点;
	C_节点面板::g节点面板重置函数[DEF_取多边形面属性节点] = f_节点重置_取多边形面属性节点;

	C_节点面板::g节点面板构建函数[DEF_取多边形面元素节点] = f_节点构建_取多边形元素节点;
	C_节点面板::g节点面板重置函数[DEF_取多边形面元素节点] = f_节点重置_取多边形元素节点;


	C_节点面板::g节点面板构建函数[DEF_设置多边形面属性节点] = f_节点构建_设置多边形面属性节点;
	C_节点面板::g节点面板重置函数[DEF_设置多边形面属性节点] = f_节点重置_设置多边形面属性节点;

	C_节点面板::g节点面板构建函数[DEF_设置多边形面UV节点] = f_节点构建_设置多边形面UV节点;
	C_节点面板::g节点面板重置函数[DEF_设置多边形面UV节点] = f_节点重置_设置多边形面UV节点;

	C_节点面板::g节点面板构建函数[DEF_取多边形面顶点节点] = f_节点构建_取多边形面顶点节点;
	C_节点面板::g节点面板重置函数[DEF_取多边形面顶点节点] = f_节点重置_取多边形面顶点节点;

	C_节点面板::g节点面板构建函数[DEF_设置多边形面顶点节点] = f_节点构建_设置多边形面顶点节点;
	C_节点面板::g节点面板重置函数[DEF_设置多边形面顶点节点] = f_节点重置_设置多边形面顶点节点;

	C_节点面板::g节点面板构建函数[DEF_设置面材质槽ID节点] = f_节点构建_设置面材质槽ID节点;
	C_节点面板::g节点面板重置函数[DEF_设置面材质槽ID节点] = f_节点重置_设置面材质槽ID节点;

	C_节点面板::g节点面板构建函数[DEF_填充网格顶点节点] = f_节点构建_填充网格顶点;
	C_节点面板::g节点面板重置函数[DEF_填充网格顶点节点] = f_节点重置_填充网格顶点;
	C_节点面板::g节点面板构建函数[DEF_填充网格纹理坐标节点] = f_节点构建_填充网格纹理坐标;
	C_节点面板::g节点面板重置函数[DEF_填充网格纹理坐标节点] = f_节点重置_填充网格纹理坐标;
	C_节点面板::g节点面板构建函数[DEF_投影纹理坐标节点] = f_节点构建_投影多边形纹理坐标;
	C_节点面板::g节点面板重置函数[DEF_投影纹理坐标节点] = f_节点重置_投影多边形纹理坐标;

	C_节点面板::g节点面板构建函数[DEF_多边形转网格节点] = f_节点构建_多边形转网格节点;
	C_节点面板::g节点面板重置函数[DEF_多边形转网格节点] = f_节点重置_多边形转网格节点;

	C_节点面板::g节点面板构建函数[DEF_取网格元素节点] = f_节点构建_取网格元素节点;
	C_节点面板::g节点面板重置函数[DEF_取网格元素节点] = f_节点重置_取网格元素节点;

	C_节点面板::g节点面板构建函数[DEF_取网格元素顶点节点] = f_节点构建_取网格元素顶点节点;
	C_节点面板::g节点面板重置函数[DEF_取网格元素顶点节点] = f_节点重置_取网格元素顶点节点;

	C_节点面板::g节点面板构建函数[DEF_取多边形边节点] = f_节点构建_取多边形边节点;
	C_节点面板::g节点面板重置函数[DEF_取多边形边节点] = f_节点重置_取多边形边节点;

	C_节点面板::g节点面板构建函数[DEF_设置网格元素顶点节点] = f_节点构建_设置网格元素顶点;
	C_节点面板::g节点面板重置函数[DEF_设置网格元素顶点节点] = f_节点重置_设置网格元素顶点;



	//================================ 计算 =========================================
	C_节点面板::g节点面板构建函数[DEF_回写节点] = f_节点构建_回写节点;
	C_节点面板::g节点面板重置函数[DEF_回写节点] = f_节点重置_回写节点;

	C_节点面板::g节点面板构建函数["单值计算节点"] = f_节点构建_单值计算;
	C_节点面板::g节点面板重置函数["单值计算节点"] = f_节点重置_单值计算;

	C_节点面板::g节点面板构建函数[DEF_位运算节点] = f_节点构建_位运算;
	C_节点面板::g节点面板重置函数[DEF_位运算节点] = f_节点重置_位运算;

	C_节点面板::g节点面板构建函数[DEF_逻辑计算节点] = f_节点构建_逻辑计算节点;
	C_节点面板::g节点面板重置函数[DEF_逻辑计算节点] = f_节点重置_逻辑计算节点;

	C_节点面板::g节点面板构建函数[DEF_单目计算节点] = f_节点构建_单目计算;
	C_节点面板::g节点面板重置函数[DEF_单目计算节点] = f_节点重置_单目计算;

	C_节点面板::g节点面板构建函数[DEF_矢量计算节点] = f_节点构建_矢量计算;
	C_节点面板::g节点面板重置函数[DEF_矢量计算节点] = f_节点重置_矢量计算;
	
	C_节点面板::g节点面板构建函数[DEF_合并XYZ节点] = f_节点构建_合并XYZ;
	C_节点面板::g节点面板重置函数[DEF_合并XYZ节点] = f_节点重置_合并XYZ;

	C_节点面板::g节点面板构建函数[DEF_分离XYZ节点] = f_节点构建_分离XYZ;
	C_节点面板::g节点面板重置函数[DEF_分离XYZ节点] = f_节点重置_分离XYZ;

	C_节点面板::g节点面板构建函数[DEF_混合计算节点] = f_节点构建_混合;
	C_节点面板::g节点面板重置函数[DEF_混合计算节点] = f_节点重置_混合;

	C_节点面板::g节点面板构建函数[DEF_设置矢量分量节点] = f_节点构建_设置矢量分量;
	C_节点面板::g节点面板重置函数[DEF_设置矢量分量节点] = f_节点重置_设置矢量分量;

	C_节点面板::g节点面板构建函数["矩阵变换节点"] = f_节点构建_矩阵变换;
	C_节点面板::g节点面板重置函数["矩阵变换节点"] = f_节点重置_矩阵变换;

	C_节点面板::g节点面板构建函数[DEF_两向量转四元数] = f_节点构建_向量转四元数;
	C_节点面板::g节点面板重置函数[DEF_两向量转四元数] = f_节点重置_向量转四元数;
	C_节点面板::g节点面板构建函数[DEF_四元数计算节点] = f_节点构建_四元数计算;
	C_节点面板::g节点面板重置函数[DEF_四元数计算节点] = f_节点重置_四元数计算;
	C_节点面板::g节点面板构建函数[DEF_四元变换节点] = f_节点构建_四元数变换;
	C_节点面板::g节点面板重置函数[DEF_四元变换节点] = f_节点重置_四元数变换;
	C_节点面板::g节点面板构建函数[DEF_向量角度组成四元数节点] = f_节点构建_向量角度组成四元数;
	C_节点面板::g节点面板重置函数[DEF_向量角度组成四元数节点] = f_节点重置_向量角度组成四元数;
	C_节点面板::g节点面板构建函数[DEF_四元数转换为欧拉角节点] = f_节点构建_四元数转换为欧拉角;
	C_节点面板::g节点面板重置函数[DEF_四元数转换为欧拉角节点] = f_节点重置_四元数转换为欧拉角;
	C_节点面板::g节点面板构建函数[DEF_四元数转换为4X4矩阵节点] = f_节点构建_四元数转换为矩阵节点;
	C_节点面板::g节点面板重置函数[DEF_四元数转换为4X4矩阵节点] = f_节点重置_四元数转换为矩阵节点;
	C_节点面板::g节点面板构建函数[DEF_顶点变换节点] = f_节点构建_顶点变换;
	C_节点面板::g节点面板重置函数[DEF_顶点变换节点] = f_节点重置_顶点变换;

	C_节点面板::g节点面板构建函数[DEF_平面到点节点] = f_节点构建_平面到点节点;
	C_节点面板::g节点面板重置函数[DEF_平面到点节点] = f_节点重置_平面到点节点;

	C_节点面板::g节点面板构建函数[DEF_平面线段相交节点] = f_节点构建_平面线段相交节点;
	C_节点面板::g节点面板重置函数[DEF_平面线段相交节点] = f_节点重置_平面线段相交节点;

	C_节点面板::g节点面板构建函数[DEF_坐标转索引节点] = f_节点构建_坐标转索引节点;
	C_节点面板::g节点面板重置函数[DEF_坐标转索引节点] = f_节点重置_坐标转索引节点;

	C_节点面板::g节点面板构建函数[DEF_索引转坐标节点] = f_节点构建_索引转坐标节点;
	C_节点面板::g节点面板重置函数[DEF_索引转坐标节点] = f_节点重置_索引转坐标节点;

	C_节点面板::g节点面板构建函数["矩阵计算节点"] = f_节点构建_矩阵计算;
	C_节点面板::g节点面板重置函数["矩阵计算节点"] = f_节点重置_矩阵计算;
	C_节点面板::g节点面板构建函数[DEF_矩阵转换节点] = f_节点构建_矩阵转换;
	C_节点面板::g节点面板重置函数[DEF_矩阵转换节点] = f_节点重置_矩阵转换;

	C_节点面板::g节点面板构建函数[DEF_圆坐标生成节点] = f_节点构建_圆坐标生成节点;
	C_节点面板::g节点面板重置函数[DEF_圆坐标生成节点] = f_节点重置_圆坐标生成节点;
	C_节点面板::g节点面板构建函数[DEF_直线坐标生成节点] = f_节点构建_直线;
	C_节点面板::g节点面板重置函数[DEF_直线坐标生成节点] = f_节点重置_直线;
	C_节点面板::g节点面板构建函数[DEF_渐变采样节点] = f_节点构建_渐变采样;
	C_节点面板::g节点面板重置函数[DEF_渐变采样节点] = f_节点重置_渐变采样;
	C_节点面板::g节点面板构建函数[DEF_单值钳制节点] = f_节点构建_单值钳制;
	C_节点面板::g节点面板重置函数[DEF_单值钳制节点] = f_节点重置_单值钳制;

	C_节点面板::g节点面板构建函数[DEF_矢量钳制节点] = f_节点构建_矢量钳制;
	C_节点面板::g节点面板重置函数[DEF_矢量钳制节点] = f_节点重置_矢量钳制;

	C_节点面板::g节点面板构建函数[DEF_三角函数节点] = f_节点构建_三角函数计算;
	C_节点面板::g节点面板重置函数[DEF_三角函数节点] = f_节点重置_三角函数计算;
	C_节点面板::g节点面板构建函数[DEF_归一化节点] = f_节点构建_归一化计算;
	C_节点面板::g节点面板重置函数[DEF_归一化节点] = f_节点重置_归一化计算;
	C_节点面板::g节点面板构建函数[DEF_向量标量计算节点] = f_节点构建_向量长度;
	C_节点面板::g节点面板重置函数[DEF_向量标量计算节点] = f_节点重置_向量长度;
	C_节点面板::g节点面板构建函数[DEF_两向量标量计算节点] = f_节点构建_两向量标量计算;
	C_节点面板::g节点面板重置函数[DEF_两向量标量计算节点] = f_节点重置_两向量标量计算;
	C_节点面板::g节点面板构建函数[DEF_旋转向量节点] = f_节点构建_旋转向量节点;
	C_节点面板::g节点面板重置函数[DEF_旋转向量节点] = f_节点重置_旋转向量节点;
	C_节点面板::g节点面板构建函数[DEF_按轴向旋转向量节点] = f_节点构建_轴向旋转向量节点;
	C_节点面板::g节点面板重置函数[DEF_按轴向旋转向量节点] = f_节点重置_轴向旋转向量节点;
	C_节点面板::g节点面板构建函数[DEF_绕点旋转节点] = f_节点构建_绕点旋转;
	C_节点面板::g节点面板重置函数[DEF_绕点旋转节点] = f_节点重置_绕点旋转;

	C_节点面板::g节点面板构建函数[DEF_步进计算节点] = f_节点构建_步进计算节点;
	C_节点面板::g节点面板重置函数[DEF_步进计算节点] = f_节点重置_步进计算节点;

	C_节点面板::g节点面板构建函数[DEF_索引数组排序节点] = f_节点构建_索引数组排序;
	C_节点面板::g节点面板重置函数[DEF_索引数组排序节点] = f_节点重置_索引数组排序;

	C_节点面板::g节点面板构建函数[DEF_取空间邻接数据节点] = f_节点构建_取空间邻接数据;
	C_节点面板::g节点面板重置函数[DEF_取空间邻接数据节点] = f_节点重置_取空间邻接数据;




	//------------------ 废弃 ----------------------
	C_节点面板::g节点面板构建函数[DEF_几何计算节点] = f_节点构建_几何计算;
	C_节点面板::g节点面板重置函数[DEF_几何计算节点] = f_节点重置_几何计算;
	
	//============================================ 变量 ============================================================
	C_节点面板::g节点面板构建函数[DEF_变量引用节点] = f_节点构建_变量引用;
	C_节点面板::g节点面板重置函数[DEF_变量引用节点] = f_节点重置_变量引用;

	C_节点面板::g节点面板构建函数[DEF_I8变量节点] = f_节点构建_I8变量;
	C_节点面板::g节点面板重置函数[DEF_I8变量节点] = f_节点重置_I8变量;

	C_节点面板::g节点面板构建函数["浮点变量节点"] = f_节点构建_单值浮点变量;
	C_节点面板::g节点面板重置函数["浮点变量节点"] = f_节点重置_单值浮点变量;
	C_节点面板::g节点面板重置函数["整数变量节点"] = f_节点重置_单值整数变量;
	C_节点面板::g节点面板构建函数["整数变量节点"] = f_节点构建_单值整数变量;

	C_节点面板::g节点面板构建函数[DEF_无符号整数变量节点] = f_节点构建_无符号整数变量;
	C_节点面板::g节点面板重置函数[DEF_无符号整数变量节点] = f_节点重置_无符号整数变量;

	C_节点面板::g节点面板构建函数["vec3变量节点"] = f_节点构建_vec3变量;
	C_节点面板::g节点面板重置函数["vec3变量节点"] = f_节点重置_vec3变量;
	C_节点面板::g节点面板构建函数[DEF_vec2变量节点] = f_节点构建_vec2变量;
	C_节点面板::g节点面板重置函数[DEF_vec2变量节点] = f_节点重置_vec2变量;

	C_节点面板::g节点面板构建函数[DEF_I8数组变量节点] = f_节点构建_I8数组变量;
	C_节点面板::g节点面板重置函数[DEF_I8数组变量节点] = f_节点重置_I8数组变量;

	C_节点面板::g节点面板构建函数[DEF_F32数组变量节点] = f_节点构建_F32数组变量;
	C_节点面板::g节点面板重置函数[DEF_F32数组变量节点] = f_节点重置_F32数组变量;
	C_节点面板::g节点面板构建函数[DEF_I32数组变量节点] = f_节点构建_I32数组变量构建;
	C_节点面板::g节点面板重置函数[DEF_I32数组变量节点] = f_节点重置_I32数组变量构建;

	C_节点面板::g节点面板构建函数[DEF_UI32数组变量节点] = f_节点构建_UI32数组变量构建;
	C_节点面板::g节点面板重置函数[DEF_UI32数组变量节点] = f_节点重置_UI32数组变量构建;

	C_节点面板::g节点面板构建函数["vec2数组变量节点"] = f_节点构建_vec2数组变量;
	C_节点面板::g节点面板重置函数["vec2数组变量节点"] = f_节点重置_vec2数组变量;
	C_节点面板::g节点面板构建函数["vec3数组变量节点"] = f_节点构建_vec3数组变量;
	C_节点面板::g节点面板重置函数["vec3数组变量节点"] = f_节点重置_vec3数组变量;

	C_节点面板::g节点面板构建函数[DEF_ivec3变量节点] = f_节点构建_ivec3变量;
	C_节点面板::g节点面板重置函数[DEF_ivec3变量节点] = f_节点重置_ivec3变量;

	C_节点面板::g节点面板构建函数[DEF_Vec4数组变量节点] = f_节点构建_vec4数组变量;
	C_节点面板::g节点面板重置函数[DEF_Vec4数组变量节点] = f_节点重置_vec4数组变量;

	C_节点面板::g节点面板构建函数[DEF_ivec2数组变量节点] = f_节点构建_ivec2数组变量;
	C_节点面板::g节点面板重置函数[DEF_ivec2数组变量节点] = f_节点重置_ivec2数组变量;

	C_节点面板::g节点面板构建函数[DEF_ivec3数组变量节点] = f_节点构建_ivec3数组变量;
	C_节点面板::g节点面板重置函数[DEF_ivec3数组变量节点] = f_节点重置_ivec3数组变量;

	C_节点面板::g节点面板构建函数[DEF_44矩阵数组变量节点] = f_节点构建_矩阵数组变量;
	C_节点面板::g节点面板重置函数[DEF_44矩阵数组变量节点] = f_节点重置_矩阵数组变量;

	C_节点面板::g节点面板构建函数["vec球数组节点"] = f_节点构建_VecSphere数组变量;

	C_节点面板::g节点面板构建函数[DEF_合并数据节点] = f_节点构建_合并数据;
	C_节点面板::g节点面板重置函数[DEF_合并数据节点] = f_节点重置_合并数据;

	C_节点面板::g节点面板构建函数["矩阵构建节点"] = f_节点构建_矩阵构建;
	C_节点面板::g节点面板重置函数["矩阵构建节点"] = f_节点重置_矩阵构建;

	C_节点面板::g节点面板构建函数[DEF_坐标构建平面变量节点] = f_节点构建_平面变量;
	C_节点面板::g节点面板重置函数[DEF_坐标构建平面变量节点] = f_节点重置_平面变量;

	C_节点面板::g节点面板构建函数[DEF_观察矩阵构建节点] = f_节点构建_观察矩阵构建;
	C_节点面板::g节点面板重置函数[DEF_观察矩阵构建节点] = f_节点重置_观察矩阵构建;

	C_节点面板::g节点面板构建函数[DEF_多边形成员数组变量节点] = f_节点构建_多边形成员数组变量;
	C_节点面板::g节点面板重置函数[DEF_多边形成员数组变量节点] = f_节点重置_多边形成员数组变量;
	

	C_节点面板::g节点面板构建函数[DEF_数组变量节点] = f_节点构建_数组变量;
	C_节点面板::g节点面板重置函数[DEF_数组变量节点] = f_节点重置_数组变量;

	C_节点面板::g节点面板构建函数[DEF_添加数组元素节点] = f_节点构建_数组添加元素;
	C_节点面板::g节点面板重置函数[DEF_添加数组元素节点] = f_节点重置_数组添加元素;

	C_节点面板::g节点面板构建函数[DEF_取数组属性节点] = f_节点构建_数组属性;
	C_节点面板::g节点面板重置函数[DEF_取数组属性节点] = f_节点重置_数组属性;

	C_节点面板::g节点面板构建函数[DEF_取数组元素节点] = f_节点构建_取数组元素;
	C_节点面板::g节点面板重置函数[DEF_取数组元素节点] = f_节点重置_取数组元素;

	C_节点面板::g节点面板构建函数[DEF_取数组头尾元素节点] = f_节点构建_取数组头尾元素;
	C_节点面板::g节点面板重置函数[DEF_取数组头尾元素节点] = f_节点重置_取数组头尾元素;

	C_节点面板::g节点面板构建函数[DEF_取内存邻接数据节点] = f_节点构建_取内存邻接数据;
	C_节点面板::g节点面板重置函数[DEF_取内存邻接数据节点] = f_节点重置_取内存邻接数据;
	
	C_节点面板::g节点面板构建函数[DEF_合并数组元素节点] = f_节点构建_合并数组;
	C_节点面板::g节点面板重置函数[DEF_合并数组元素节点] = f_节点重置_合并数组;
	C_节点面板::g节点面板构建函数[DEF_插入数组节点] = f_节点构建_插入数组节点;
	C_节点面板::g节点面板重置函数[DEF_插入数组节点] = f_节点重置_插入数组节点;

	C_节点面板::g节点面板构建函数[DEF_删除数组元素节点] = f_节点构建_删除数组元素;
	C_节点面板::g节点面板重置函数[DEF_删除数组元素节点] = f_节点重置_删除数组元素;

	C_节点面板::g节点面板构建函数[DEF_查找数组元素节点] = f_节点构建_查找数组元素;
	C_节点面板::g节点面板重置函数[DEF_查找数组元素节点] = f_节点重置_查找数组元素;

	C_节点面板::g节点面板构建函数[DEF_数组元素统计节点] = f_节点构建_数组元素统计;
	C_节点面板::g节点面板重置函数[DEF_数组元素统计节点] = f_节点重置_数组元素统计;

	C_节点面板::g节点面板构建函数[DEF_复制数组节点] = f_节点构建_复制数据;
	C_节点面板::g节点面板重置函数[DEF_复制数组节点] = f_节点重置_复制数据;

	C_节点面板::g节点面板构建函数[DEF_数组重排节点] = f_节点构建_数组重排;
	C_节点面板::g节点面板重置函数[DEF_数组重排节点] = f_节点重置_数组重排;

	C_节点面板::g节点面板构建函数[DEF_数组打乱节点] = f_节点构建_数组打乱;
	C_节点面板::g节点面板重置函数[DEF_数组打乱节点] = f_节点重置_数组打乱;

	C_节点面板::g节点面板构建函数[DEF_数组抽取节点] = f_节点构建_数组抽取;
	C_节点面板::g节点面板重置函数[DEF_数组抽取节点] = f_节点重置_数组抽取;

	C_节点面板::g节点面板构建函数[DEF_射线物体相交节点] = f_节点构建_射线相交;
	C_节点面板::g节点面板重置函数[DEF_射线物体相交节点] = f_节点重置_射线相交;


	C_节点面板::g节点面板构建函数["线段1D数据节点"] = f_节点构建_线段1D变量;


	C_节点面板::g节点面板构建函数["物理体节点"] = f_节点构建_物理体;
	C_节点面板::g节点面板构建函数["PBF解算器节点"] = f_节点构建_PBF解算器;
	C_节点面板::g节点面板构建函数["FleX参数节点"] = f_节点构建_FleX参数;
	C_节点面板::g节点面板构建函数["发射节点"] = f_节点构建_发射;
	C_节点面板::g节点面板构建函数["解算器更新节点"] = f_节点构建_解算器模拟;


	//================================= 物体 ======================================
	C_节点面板::g节点面板构建函数["物体节点"] = f_节点构建_物体节点;
	C_节点面板::g节点面板重置函数["物体节点"] = f_节点重置_物体节点;

	C_节点面板::g节点面板构建函数[DEF_引用物体节点] = f_节点构建_引用物体节点;
	C_节点面板::g节点面板重置函数[DEF_引用物体节点] = f_节点重置_引用物体节点;
	C_节点面板::g节点面板构建函数[DEF_取物体节点] = f_节点构建_取物体节点;
	C_节点面板::g节点面板重置函数[DEF_取物体节点] = f_节点重置_取物体节点;
	C_节点面板::g节点面板构建函数[DEF_取物体变换节点] = f_节点构建_取物体变换节点;
	C_节点面板::g节点面板重置函数[DEF_取物体变换节点] = f_节点重置_取物体变换节点;
	C_节点面板::g节点面板构建函数[DEF_取物体矩阵节点] = f_节点构建_取物体矩阵节点;
	C_节点面板::g节点面板重置函数[DEF_取物体矩阵节点] = f_节点重置_取物体矩阵节点;
	C_节点面板::g节点面板构建函数[DEF_查找子物体节点] = f_节点构建_查找子物体节点;
	C_节点面板::g节点面板重置函数[DEF_查找子物体节点] = f_节点重置_查找子物体节点;

	C_节点面板::g节点面板构建函数["物体父子关系节点"] = f_节点构建_物体父子关系节点;
	C_节点面板::g节点面板构建函数[DEF_取物体材质节点] = f_节点构建_取物体材质节点;
	C_节点面板::g节点面板构建函数["设置物体数据节点"] = f_节点构建_设置物体数据节点;
	C_节点面板::g节点面板构建函数["骨头节点"] = f_节点构建_骨头节点;
	C_节点面板::g节点面板构建函数["骨骼节点"] = f_节点构建_骨骼节点;
	C_节点面板::g节点面板构建函数["骨骼IK节点"] = f_节点构建_骨骼IK节点;
	C_节点面板::g节点面板构建函数["物体拷贝节点"] = f_节点构建_物体拷贝节点;
	C_节点面板::g节点面板构建函数["物体绑定骨骼节点"] = f_节点构建_物体拷贝节点;

	C_节点面板::g节点面板构建函数["设置物体矩阵节点"] = f_节点构建_设置物体矩阵节点;
	C_节点面板::g节点面板重置函数["设置物体矩阵节点"] = f_节点重置_设置物体矩阵节点;

	C_节点面板::g节点面板构建函数[DEF_设置摄像机属性节点] = f_节点构建_设置摄像机属性节点;
	C_节点面板::g节点面板重置函数[DEF_设置摄像机属性节点] = f_节点重置_设置摄像机属性节点;

	C_节点面板::g节点面板构建函数["设置物体变换节点"] = f_节点构建_设置物体变换节点;
	C_节点面板::g节点面板重置函数["设置物体变换节点"] = f_节点重置_设置物体变换节点;
	
	C_节点面板::g节点面板构建函数[DEF_外部加载物体节点] = f_节点构建_外部加载物体节点;
	C_节点面板::g节点面板重置函数[DEF_外部加载物体节点] = f_节点重置_外部加载物体节点;

	C_节点面板::g节点面板构建函数[DEF_摄像机节点] = f_节点构建_摄像机节点;
	C_节点面板::g节点面板重置函数[DEF_摄像机节点] = f_节点重置_摄像机节点;

	C_节点面板::g节点面板构建函数[DEF_目标摄像机节点] = f_节点构建_目标摄像机节点;
	C_节点面板::g节点面板重置函数[DEF_目标摄像机节点] = f_节点重置_目标摄像机节点;

	C_节点面板::g节点面板构建函数[DEF_点光源节点] = f_节点构建_点光源节点;
	C_节点面板::g节点面板重置函数[DEF_点光源节点] = f_节点重置_点光源节点;
	C_节点面板::g节点面板构建函数[DEF_区域光节点] = f_节点构建_面光源节点;
	C_节点面板::g节点面板重置函数[DEF_区域光节点] = f_节点重置_面光源节点;
	C_节点面板::g节点面板构建函数[DEF_聚光灯节点] = f_节点构建_聚光灯节点;
	C_节点面板::g节点面板重置函数[DEF_聚光灯节点] = f_节点重置_聚光灯节点;
	C_节点面板::g节点面板构建函数[DEF_平行光节点] = f_节点构建_平行光节点;
	C_节点面板::g节点面板重置函数[DEF_平行光节点] = f_节点重置_平行光节点;

	C_节点面板::g节点面板构建函数[DEF_物体虚拟体节点] = f_节点构建_物体虚拟体节点;
	C_节点面板::g节点面板重置函数[DEF_物体虚拟体节点] = f_节点重置_物体虚拟体节点;

	C_节点面板::g节点面板构建函数[DEF_选择物体节点] = f_节点构建_选择物体节点;
	C_节点面板::g节点面板重置函数[DEF_选择物体节点] = f_节点重置_选择物体节点;


	//================================= 材质着色 ======================================
	C_节点面板::g节点面板构建函数[DEF_材质槽节点] = f_节点构建_材质槽;
	C_节点面板::g节点面板重置函数[DEF_材质槽节点] = f_节点重置_材质槽;
	C_节点面板::g节点面板构建函数[DEF_材质编辑节点] = f_节点构建_材质;
	C_节点面板::g节点面板重置函数[DEF_材质编辑节点] = f_节点重置_材质;

	C_节点面板::g节点面板构建函数[DEF_当前材质节点] = f_节点构建_当前材质;
	C_节点面板::g节点面板重置函数[DEF_当前材质节点] = f_节点重置_当前材质;

	C_节点面板::g节点面板构建函数[DEF_着色器节点] = f_节点构建_着色器;
	C_节点面板::g节点面板重置函数[DEF_着色器节点] = f_节点重置_着色器;
	C_节点面板::g节点面板构建函数[DEF_纹理节点] = f_节点构建_纹理;
	C_节点面板::g节点面板重置函数[DEF_纹理节点] = f_节点重置_纹理;
	C_节点面板::g节点面板构建函数[DEF_外部纹理节点] = f_节点构建_外部纹理;
	C_节点面板::g节点面板重置函数[DEF_外部纹理节点] = f_节点重置_外部纹理;

	C_节点面板::g节点面板构建函数[DEF_外部纹理集节点] = f_节点构建_外部纹理集;
	C_节点面板::g节点面板重置函数[DEF_外部纹理集节点] = f_节点重置_外部纹理集;

	C_节点面板::g节点面板构建函数[DEF_渐变纹理节点] = f_节点构建_渐变纹理;
	C_节点面板::g节点面板重置函数[DEF_渐变纹理节点] = f_节点重置_渐变纹理;
	C_节点面板::g节点面板构建函数[DEF_棋盘格纹理节点] = f_节点构建_棋盘格纹理;
	C_节点面板::g节点面板重置函数[DEF_棋盘格纹理节点] = f_节点重置_棋盘格纹理;
	C_节点面板::g节点面板构建函数[DEF_噪波纹理节点] = f_节点构建_噪波纹理属性;
	C_节点面板::g节点面板重置函数[DEF_噪波纹理节点] = f_节点重置_噪波纹理属性;
	C_节点面板::g节点面板构建函数[DEF_2D纹理采样节点] = f_节点构建_2D纹理采样;
	C_节点面板::g节点面板重置函数[DEF_2D纹理采样节点] = f_节点重置_2D纹理采样;
	C_节点面板::g节点面板构建函数[DEF_设置网格材质节点] = f_节点构建_设置物体材质;
	C_节点面板::g节点面板重置函数[DEF_设置网格材质节点] = f_节点重置_设置物体材质;
	C_节点面板::g节点面板构建函数[DEF_PBR着色器节点] = f_节点构建_设置PBR材质属性;
	C_节点面板::g节点面板重置函数[DEF_PBR着色器节点] = f_节点重置_设置PBR材质属性;
	C_节点面板::g节点面板构建函数[DEF_基于物理计算着色节点] = f_节点构建_基于物理计算着色;
	C_节点面板::g节点面板重置函数[DEF_基于物理计算着色节点] = f_节点重置_基于物理计算着色;
	C_节点面板::g节点面板构建函数[DEF_几何数据节点] = f_节点构建_几何数据;
	C_节点面板::g节点面板重置函数[DEF_几何数据节点] = f_节点重置_几何数据;
	C_节点面板::g节点面板构建函数[DEF_光线数据节点] = f_节点构建_光线数据;
	C_节点面板::g节点面板重置函数[DEF_光线数据节点] = f_节点重置_光线数据;
	C_节点面板::g节点面板构建函数[DEF_几何UV数据节点] = f_节点构建_几何UV数据;
	C_节点面板::g节点面板重置函数[DEF_几何UV数据节点] = f_节点重置_几何UV数据;


	//================================= 逻辑 ======================================
	C_节点面板::g节点面板构建函数[DEF_循环节点] = f_节点构建_循环;
	C_节点面板::g节点面板重置函数[DEF_循环节点] = f_节点重置_循环;
	C_节点面板::g节点面板构建函数[DEF_迭代节点] = f_节点构建_迭代;
	C_节点面板::g节点面板重置函数[DEF_迭代节点] = f_节点重置_迭代;
	C_节点面板::g节点面板构建函数[DEF_循环头节点] = f_节点构建_循环迭代;
	C_节点面板::g节点面板重置函数[DEF_循环头节点] = f_节点重置_循环迭代;
	C_节点面板::g节点面板构建函数[DEF_循环尾节点] = f_节点构建_循环尾;
	C_节点面板::g节点面板重置函数[DEF_循环尾节点] = f_节点重置_循环尾;
	C_节点面板::g节点面板构建函数[DEF_输入组节点] = f_节点构建_输入组;
	C_节点面板::g节点面板重置函数[DEF_输入组节点] = f_节点重置_输入组;
	C_节点面板::g节点面板构建函数[DEF_输出组节点] = f_节点构建_输出组;
	C_节点面板::g节点面板重置函数[DEF_输出组节点] = f_节点重置_输出组;
	C_节点面板::g节点面板构建函数[DEF_跳过节点] = f_节点构建_跳过;
	C_节点面板::g节点面板重置函数[DEF_跳过节点] = f_节点重置_跳过;
	C_节点面板::g节点面板构建函数[DEF_Python节点] = f_节点构建_Python;
	C_节点面板::g节点面板重置函数[DEF_Python节点] = f_节点重置_Python;
	C_节点面板::g节点面板构建函数[DEF_分支判断节点] = f_节点构建_分支判断;
	C_节点面板::g节点面板重置函数[DEF_分支判断节点] = f_节点重置_分支判断;
	C_节点面板::g节点面板构建函数[DEF_函数节点] = f_节点构建_函数;
	C_节点面板::g节点面板重置函数[DEF_函数节点] = f_节点重置_函数;
	C_节点面板::g节点面板构建函数[DEF_包节点] = f_节点构建_包;
	C_节点面板::g节点面板重置函数[DEF_包节点] = f_节点重置_包;

	C_节点面板::g节点面板构建函数[DEF_插座转接节点] = f_节点构建_插座转接;
	C_节点面板::g节点面板重置函数[DEF_插座转接节点] = f_节点重置_插座转接;

	C_节点面板::g节点面板构建函数[DEF_面板框节点] = f_节点构建_面板框;
	C_节点面板::g节点面板重置函数[DEF_面板框节点] = f_节点重置_面板框;





	C_节点面板::g节点面板构建函数[DEF_物理几何体节点]      = f_节点构建_物理几何体;
	C_节点面板::g节点面板重置函数[DEF_物理几何体节点]      = f_节点重置_物理几何体;
	C_节点面板::g节点面板构建函数[DEF_物理体节点]          = f_节点构建_物理体;
	C_节点面板::g节点面板重置函数[DEF_物理体节点]          = f_节点重置_物理体;
	C_节点面板::g节点面板构建函数[DEF_物理引擎节点]         = f_节点构建_物理引擎;
	C_节点面板::g节点面板重置函数[DEF_物理引擎节点]         = f_节点重置_物理引擎;
	C_节点面板::g节点面板构建函数[DEF_物理体绑定物体节点]   = f_节点构建_物理体绑定物体节点;
	C_节点面板::g节点面板重置函数[DEF_物理体绑定物体节点]   = f_节点重置_物理体绑定物体节点;
	C_节点面板::g节点面板构建函数[DEF_取物理体节点]         = f_节点构建_取物理体节点;
	C_节点面板::g节点面板重置函数[DEF_取物理体节点]         = f_节点重置_取物理体节点;
	C_节点面板::g节点面板构建函数[DEF_物理引擎内部几何节点] = f_节点构建_物理引擎内部几何节点;
	C_节点面板::g节点面板重置函数[DEF_物理引擎内部几何节点] = f_节点重置_物理引擎内部几何节点;
	C_节点面板::g节点面板构建函数[DEF_应用力节点]           = f_节点构建_物理应用力;
	C_节点面板::g节点面板重置函数[DEF_应用力节点]           = f_节点重置_物理应用力;
	C_节点面板::g节点面板构建函数[DEF_更新肌腱节点]         = f_节点构建_更新肌腱力度;




	//================================ 容器 =========================================

	C_节点面板::g节点面板构建函数[DEF_物体缓存节点]      = f_节点构建_物体缓存;
	C_节点面板::g节点面板重置函数[DEF_物体缓存节点]      = f_节点重置_物体缓存;

	C_节点面板::g节点面板构建函数[DEF_网格缓存写入节点] = f_节点构建_网格缓存写入;
	C_节点面板::g节点面板重置函数[DEF_网格缓存写入节点] = f_节点重置_网格缓存写入;

	C_节点面板::g节点面板构建函数[DEF_读取网格缓存节点] = f_节点构建_读取网格缓存;
	C_节点面板::g节点面板重置函数[DEF_读取网格缓存节点] = f_节点重置_读取网格缓存;


	//============================== 调试 ====================================
	C_节点面板::g节点面板构建函数[DEF_调试输出节点]      = f_节点构建_调试输出;
	C_节点面板::g节点面板重置函数[DEF_调试输出节点]      = f_节点重置_调试输出;

	C_节点面板::g节点面板构建函数[DEF_控制台输出节点] = f_节点构建_控制台输出节点;
	C_节点面板::g节点面板重置函数[DEF_控制台输出节点] = f_节点重置_控制台输出节点;


}




static void f_on_1级节点创建菜单项(C_Widget* self, const std::wstring name, uint16 id) {
	C_节点面板* node = nullptr;
	if (name == L"转接") {
		node = f_节点构建_插座转接(*g当前UI环境, *S_框架::g_3D视口环境, nullptr);
	}
	else if(name == L"框") {
		node = f_节点构建_面板框(*g当前UI环境, *S_框架::g_3D视口环境, nullptr);
	}
	if (node) {
		fun_节点视口回调(node, true);
	}
}

void on_2级几何节点创建菜单项(C_Widget* self, const std::wstring name, uint16 id) {
	//f_节点面板构建_回调函数指针 create_fn = nullptr;
	C_节点面板* node = nullptr;
	if (name == L"网格") {
		node = f_节点构建_几何网格(*g当前UI环境, *S_框架::g_3D视口环境, nullptr);
	}
	else if (name == L"平面") {
		node = f_节点构建_几何平面(*g当前UI环境, *S_框架::g_3D视口环境, nullptr);
	}
	else if (name == L"球体") {
		node = f_节点构建_几何球体(*g当前UI环境, *S_框架::g_3D视口环境, nullptr);
	}
	else if (name == L"圆环") {
		node = f_节点构建_几何球体(*g当前UI环境, *S_框架::g_3D视口环境, nullptr);
	}
	else if (name == L"方体") {
		node = f_节点构建_几何矩形(*g当前UI环境, *S_框架::g_3D视口环境, nullptr);
	}
	else if (name == L"圆柱") {
		node = f_节点构建_几何球体(*g当前UI环境, *S_框架::g_3D视口环境, nullptr);
	}
	else if (name == L"圆锥") {
		node = f_节点构建_几何球体(*g当前UI环境, *S_框架::g_3D视口环境, nullptr);
	}
	else if (name == L"六面") {
		node = f_节点构建_几何球体(*g当前UI环境, *S_框架::g_3D视口环境, nullptr);
	}
	else if (name == L"线框立方体") {
		node = f_节点构建_线框立方体(*g当前UI环境, *S_框架::g_3D视口环境, nullptr);
	}
	else if (name == L"几何") {
		node = f_节点构建_几何(*g当前UI环境, *S_框架::g_3D视口环境, nullptr);
	}
	if (node) {
		fun_节点视口回调(node, true);
	}
}

void on_2创建多边形节点菜单项(C_Widget* self, const std::wstring name, uint16 id) {
	C_节点面板* node = nullptr;

	if (name == L"平面") {
		node = f_节点构建_几何平面(*g当前UI环境, *S_框架::g_3D视口环境, nullptr);
	}
	else if (name == L"球体") {
		node = f_节点构建_几何球体(*g当前UI环境, *S_框架::g_3D视口环境, nullptr);
	}
	else if (name == L"圆环") {
		node = f_节点构建_几何球体(*g当前UI环境, *S_框架::g_3D视口环境, nullptr);
	}
	else if (name == L"方体") {
		node = f_节点构建_几何矩形(*g当前UI环境, *S_框架::g_3D视口环境, nullptr);
	}
	else if (name == L"圆柱") {
		node = f_节点构建_几何球体(*g当前UI环境, *S_框架::g_3D视口环境, nullptr);
	}
	else if (name == L"圆锥") {
		node = f_节点构建_几何球体(*g当前UI环境, *S_框架::g_3D视口环境, nullptr);
	}
	else if (name == L"六面") {
		node = f_节点构建_几何球体(*g当前UI环境, *S_框架::g_3D视口环境, nullptr);
	}
	else if (name == L"几何ID") {
		node = f_节点构建_几何ID(*g当前UI环境, *S_框架::g_3D视口环境, nullptr);
	}
	else if (name == L"当前多边形") {
		node = f_节点构建_当前多边形(*g当前UI环境, *S_框架::g_3D视口环境, nullptr);
	}
	else if (name == L"基本多边形") {
		node = f_节点构建_基本多边形(*g当前UI环境, *S_框架::g_3D视口环境, nullptr);
	}
	else if (name == L"边") {
		node = f_节点构建_多边形边(*g当前UI环境, *S_框架::g_3D视口环境, nullptr);
	}
	else if (name == L"面") {
		node = f_节点构建_多边形面(*g当前UI环境, *S_框架::g_3D视口环境, nullptr);
	}
	else if (name == L"+顶点") {
		node = f_节点构建_多边形添加顶点(*g当前UI环境, *S_框架::g_3D视口环境, nullptr);
	}
	else if (name == L"-顶点") {
		node = f_节点构建_多边形删除顶点(*g当前UI环境, *S_框架::g_3D视口环境, nullptr);
	}
	else if (name == L"多边形") {
		node = f_节点构建_多边形(*g当前UI环境, *S_框架::g_3D视口环境, nullptr);
	}
	else if (name == L"+UV") {
		node = f_节点构建_添加多边形纹理坐标(*g当前UI环境, *S_框架::g_3D视口环境, nullptr);
	}
	else if (name == L"+元素") {
		node = f_节点构建_添加多边形元素(*g当前UI环境, *S_框架::g_3D视口环境, nullptr);
	}
	else if (name == L"取索引") {
		node = f_节点构建_取多边形索引节点(*g当前UI环境, *S_框架::g_3D视口环境, nullptr);
	}
	else if (name == L"取面属性") {
		node = f_节点构建_取多边形面属性节点(*g当前UI环境, *S_框架::g_3D视口环境, nullptr);
	}
	else if (name == L"取多边形元素") {
		node = f_节点构建_取多边形元素节点(*g当前UI环境, *S_框架::g_3D视口环境, nullptr);
	}
	else if (name == L"设置面属性") {
		node = f_节点构建_设置多边形面属性节点(*g当前UI环境, *S_框架::g_3D视口环境, nullptr);
	}
	else if (name == L"设置面UV") {
		node = f_节点构建_设置多边形面UV节点(*g当前UI环境, *S_框架::g_3D视口环境, nullptr);
	}
	else if (name == L"设置材质槽ID") {
		node = f_节点构建_设置面材质槽ID节点(*g当前UI环境, *S_框架::g_3D视口环境, nullptr);
	}
	if (node) fun_节点视口回调(node, true);
}

void on_2级灯光节点创建菜单项(C_Widget* self, const std::wstring name, uint16 id) {
	f_NodeView_设置当前节点添加_树类型限制(E_节点树类型::e_type_物体节点树);

	C_节点面板* node = nullptr;
	if (name == L"平行光") {
		node = f_节点构建_平行光节点(*g当前UI环境, *S_框架::g_3D视口环境, nullptr);
	}
	else if (name == L"聚光灯") {
		node = f_节点构建_聚光灯节点(*g当前UI环境, *S_框架::g_3D视口环境, nullptr);
	}
	else if (name == L"点光源") {
		node = f_节点构建_点光源节点(*g当前UI环境, *S_框架::g_3D视口环境, nullptr);
	}
	else if (name == L"面光源") {
		node = f_节点构建_面光源节点(*g当前UI环境, *S_框架::g_3D视口环境, nullptr);
	}
	if (node) fun_节点视口回调(node, true);
}

S_菜单创建参数 f_menu参数_灯光() {
	S_菜单创建参数 灯光创建参数 = {
		on_2级灯光节点创建菜单项, {
			//{L"平行光",	"", 0},
			//{L"聚光灯", "", 0},
			{L"点光源",	"", 0},
			{L"面光源", "", 0},
		}
	};
	return 灯光创建参数;
}


static void f_on_变量2级节点创建菜单项(C_Widget* self, const std::wstring name, uint16 id) {
	C_节点面板* node = nullptr;
	if (name == L"引用") {
		node = f_节点构建_变量引用(*g当前UI环境, *S_框架::g_3D视口环境);
	}
	else if (name == L"I8变量") {
		node = f_节点构建_I8变量(*g当前UI环境, *S_框架::g_3D视口环境);
	}
	else if (name == L"浮点变量") {
		node = f_节点构建_单值浮点变量(*g当前UI环境, *S_框架::g_3D视口环境);
	}
	else if (name == L"整数变量") {
		node = f_节点构建_单值整数变量(*g当前UI环境, *S_框架::g_3D视口环境);
	}
	else if (name == L"无符号整数") {
		node = f_节点构建_无符号整数变量(*g当前UI环境, *S_框架::g_3D视口环境);
	}
	else if (name == L"线段变量") {
		node = f_节点构建_线段变量(*g当前UI环境, *S_框架::g_3D视口环境);
	}
	else if (name == L"vec3") {
		node = f_节点构建_vec3变量(*g当前UI环境, *S_框架::g_3D视口环境, nullptr);
	}
	else if (name == L"ivec3") {
		node = f_节点构建_ivec3变量(*g当前UI环境, *S_框架::g_3D视口环境, nullptr);
	}
	else if (name == L"vec2") {
		node = f_节点构建_vec2变量(*g当前UI环境, *S_框架::g_3D视口环境, nullptr);
	}
	else if (name == L"[I8]") {
		node = f_节点构建_I8数组变量(*g当前UI环境, *S_框架::g_3D视口环境);
	}
	else if (name == L"[F32]") {
		node = f_节点构建_F32数组变量(*g当前UI环境, *S_框架::g_3D视口环境);
	}
	else if (name == L"[I32]") {
		node = f_节点构建_I32数组变量构建(*g当前UI环境, *S_框架::g_3D视口环境, nullptr);
	}
	else if (name == L"[UI32]") {
		node = f_节点构建_UI32数组变量构建(*g当前UI环境, *S_框架::g_3D视口环境, nullptr);
	}
	else if (name == L"[vec2]") {
		node = f_节点构建_vec2数组变量(*g当前UI环境, *S_框架::g_3D视口环境);
	}
	else if (name == L"[vec3]") {
		node = f_节点构建_vec3数组变量(*g当前UI环境, *S_框架::g_3D视口环境);
	}
	else if (name == L"[vec4]") {
		node = f_节点构建_vec4数组变量(*g当前UI环境, *S_框架::g_3D视口环境);
	}
	else if (name == L"[ivec2]") {
		node = f_节点构建_ivec2数组变量(*g当前UI环境, *S_框架::g_3D视口环境);
	}
	else if (name == L"[ivec3]") {
		node = f_节点构建_ivec3数组变量(*g当前UI环境, *S_框架::g_3D视口环境);
	}
	else if (name == L"[平面]") {
		node = f_节点构建_平面变量(*g当前UI环境, *S_框架::g_3D视口环境, nullptr);
	}
	else if (name == L"[VecSphere]") {
		node = f_节点构建_VecSphere数组变量(*g当前UI环境, *S_框架::g_3D视口环境);
	}
	else if (name == L"[构建矩阵]") {
		node = f_节点构建_矩阵构建(*g当前UI环境, *S_框架::g_3D视口环境, nullptr);
	}
	else if (name == L"[线段]") {
		node = f_节点构建_线段1D变量(*g当前UI环境, *S_框架::g_3D视口环境, nullptr);
	}
	else if (name == L"[多边形成员]") {
		node = f_节点构建_多边形成员数组变量(*g当前UI环境, *S_框架::g_3D视口环境, nullptr);
	}
	else if (name == L"合并元素") {
		node = f_节点构建_合并数据(*g当前UI环境, *S_框架::g_3D视口环境);
	}
	else if (name == L"矩阵") {
		 node = f_节点构建_矩阵数组变量(*g当前UI环境, *S_框架::g_3D视口环境);
	}
	else if (name == L"转换") {
		node = f_节点构建_转换数据(*g当前UI环境, *S_框架::g_3D视口环境);
	}
	else if (name == L"取成员") {
		node = f_节点构建_取成员数据(*g当前UI环境, *S_框架::g_3D视口环境);
	}
	else if (name == L"坐标取数据") {
		node = f_节点构建_坐标取数据(*g当前UI环境, *S_框架::g_3D视口环境);
	}
	else if (name == L"观察矩阵") {
		node = f_节点构建_观察矩阵构建(*g当前UI环境, *S_框架::g_3D视口环境, nullptr);
	}
	else if (name == L"数组") {
		node = f_节点构建_数组变量(*g当前UI环境, *S_框架::g_3D视口环境, nullptr); 
	}
	else if (name == L"添加元素") {
		node = f_节点构建_数组添加元素(*g当前UI环境, *S_框架::g_3D视口环境, nullptr);
	}
	else if (name == L"删除元素") {
		node = f_节点构建_删除数组元素(*g当前UI环境, *S_框架::g_3D视口环境, nullptr);
	}
	else if (name == L"数组属性") {
		node = f_节点构建_数组属性(*g当前UI环境, *S_框架::g_3D视口环境, nullptr);
	}
	else if (name == L"取元素") {
		node = f_节点构建_取数组元素(*g当前UI环境, *S_框架::g_3D视口环境, nullptr);
	}
	else if (name == L"取头尾元素") {
		node = f_节点构建_取数组头尾元素(*g当前UI环境, *S_框架::g_3D视口环境, nullptr);
	}
	else if (name == L"查找元素") {
		node = f_节点构建_查找数组元素(*g当前UI环境, *S_框架::g_3D视口环境, nullptr);
	}
	else if (name == L"取内存邻接") {
		node = f_节点构建_取内存邻接数据(*g当前UI环境, *S_框架::g_3D视口环境, nullptr);
	}
	else if (name == L"合并数组") {
		node = f_节点构建_合并数组(*g当前UI环境, *S_框架::g_3D视口环境, nullptr);
	}
	else if (name == L"插入数组") {
		node = f_节点构建_插入数组节点(*g当前UI环境, *S_框架::g_3D视口环境, nullptr);
	}
	else if (name == L"数组元素统计") {
	node = f_节点构建_数组元素统计(*g当前UI环境, *S_框架::g_3D视口环境, nullptr);
	}
	else if (name == L"复制数组") {
		node = f_节点构建_复制数据(*g当前UI环境, *S_框架::g_3D视口环境, nullptr);
	}
	else if (name == L"数组重排") {
		node = f_节点构建_数组重排(*g当前UI环境, *S_框架::g_3D视口环境, nullptr);
	}
	else if (name == L"数组打乱") {
		node = f_节点构建_数组打乱(*g当前UI环境, *S_框架::g_3D视口环境, nullptr);
	}
	else if (name == L"数组抽取") {
		node = f_节点构建_数组抽取(*g当前UI环境, *S_框架::g_3D视口环境, nullptr);
	}
	else if (name == L"取空间邻接") {
		node = f_节点构建_取空间邻接数据(*g当前UI环境, *S_框架::g_3D视口环境, nullptr);
	}
	if(node) fun_节点视口回调(node, true);
}

void f_on_2级容器节点创建菜单项(C_Widget* self, const std::wstring name, uint16 id) {
	C_节点面板* node = nullptr;
	if (name == L"点距八叉树") {
		node = f_节点构建_点距八叉树(*g当前UI环境, *S_框架::g_3D视口环境, nullptr);
	}
	else if (name == L"包") {
		node = f_节点构建_包(*g当前UI环境, *S_框架::g_3D视口环境, nullptr);
	}
	else if (name == L"缓存写入") {
		node = f_节点构建_数据缓存写入(*g当前UI环境, *S_框架::g_3D视口环境, nullptr);
	}
	else if (name == L"缓存读取") {
		node = f_节点构建_数据缓存读取(*g当前UI环境, *S_框架::g_3D视口环境, nullptr);
	}
	else if (name == L"物体缓存") {
		node = f_节点构建_物体缓存(*g当前UI环境, *S_框架::g_3D视口环境, nullptr);
	}
	else if (name == L"写网格缓存") {
		node = f_节点构建_网格缓存写入(*g当前UI环境, *S_框架::g_3D视口环境, nullptr);
	}
	else if (name == L"读网格缓存") {
		node = f_节点构建_读取网格缓存(*g当前UI环境, *S_框架::g_3D视口环境, nullptr);
	}
	if (node) fun_节点视口回调(node, true);
}

void f_on_逻辑2级节点创建菜单项(C_Widget* self, const std::wstring name, uint16 id) {
	C_节点面板* node = nullptr;
	if (name == L"手动执行") {
		node = f_节点构建_手动执行(*g当前UI环境);
	}
	else if (name == L"loop") {
		C_节点面板* node_头 = f_节点构建_循环(*g当前UI环境, *S_框架::g_3D视口环境, nullptr);
		C_节点面板* node_尾 = f_节点构建_循环尾(*g当前UI环境, *S_框架::g_3D视口环境, nullptr);
		
		f_配对循环节点头和尾((C_循环节点*)(node_头->m_NodeData), (C_循环尾节点*)(node_尾->m_NodeData));
		std::vector<C_节点面板*> nodes{ node_头, node_尾 };
		fun_创建多节点添加到视口回调(nodes, true);
		return;
	}
	else if (name == L"迭代") {
		C_节点面板* node_头 = f_节点构建_迭代(*g当前UI环境, *S_框架::g_3D视口环境, nullptr);
		C_节点面板* node_尾 = f_节点构建_循环尾(*g当前UI环境, *S_框架::g_3D视口环境, nullptr);

		f_配对循环节点头和尾(node_头->m_NodeData, (C_循环尾节点*)(node_尾->m_NodeData));
		std::vector<C_节点面板*> nodes{ node_头, node_尾 };
		fun_创建多节点添加到视口回调(nodes, true);
		return;
	}
	else if (name == L"for") {
		node = f_节点构建_循环迭代(*g当前UI环境, *S_框架::g_3D视口环境, nullptr);
	}
	else if (name == L"函数") {
		node = f_节点构建_函数(*g当前UI环境, *S_框架::g_3D视口环境, nullptr, nullptr);
	}
	else if (name == L"跳过") {
		node = f_节点构建_跳过(*g当前UI环境, *S_框架::g_3D视口环境, nullptr, nullptr);
	}
	else if (name == L"判断") {
		node = f_节点构建_分支判断(*g当前UI环境, *S_框架::g_3D视口环境, nullptr, nullptr);
	}
	else if (name == L"End") {
		node = f_节点构建_循环尾(*g当前UI环境, *S_框架::g_3D视口环境, nullptr, nullptr);
	}
	if (node) fun_节点视口回调(node, true);
}


void f_on_网格2级节点创建菜单项(C_Widget* self, const std::wstring name, uint16 id) {
	C_节点面板* node = nullptr;

	if (name == L"网格") {
		node = f_节点构建_几何网格(*g当前UI环境, *S_框架::g_3D视口环境, nullptr);
	}
	else if (name == L"网格编辑") {
		node = f_节点构建_编辑网格(*g当前UI环境, *S_框架::g_3D视口环境, nullptr);
	}
	else if (name == L"从网格构建体素") {
		node = f_节点构建_网格体素(*g当前UI环境, *S_框架::g_3D视口环境, nullptr);
	}
	else if (name == L"设置材质") {
		node = f_节点构建_设置材质ID(*g当前UI环境, *S_框架::g_3D视口环境, nullptr);
	}
	else if (name == L"网格采样") {
		node = f_节点构建_网格采样(*g当前UI环境, *S_框架::g_3D视口环境, nullptr);
	}
	else if (name == L"计算法线") {
		node = f_节点构建_计算网格法线(*g当前UI环境, *S_框架::g_3D视口环境, nullptr);
	}
	else if (name == L"截取网格") {
		node = f_节点构建_截取网格(*g当前UI环境, *S_框架::g_3D视口环境, nullptr);
	}
	else if (name == L"网格属性") {
		node = f_节点构建_网格属性(*g当前UI环境, *S_框架::g_3D视口环境, nullptr);
	}
	else if (name == L"填充顶点") {
		node = f_节点构建_填充网格顶点(*g当前UI环境, *S_框架::g_3D视口环境, nullptr);
	}
	else if (name == L"填充纹理坐标") {
		node = f_节点构建_填充网格纹理坐标(*g当前UI环境, *S_框架::g_3D视口环境, nullptr);
	}
	else if (name == L"多边形桥接") {
		node = f_节点构建_多边形桥接节点(*g当前UI环境, *S_框架::g_3D视口环境, nullptr);
	}
	else if (name == L"点桥接") {
		node = f_节点构建_点桥接节点(*g当前UI环境, *S_框架::g_3D视口环境, nullptr);
	}
	else if (name == L"边实体化") {
		node = f_节点构建_多边形边实体化节点(*g当前UI环境, *S_框架::g_3D视口环境, nullptr);
	}
	else if (name == L"边网格化") {
		node = f_节点构建_边网格化节点(*g当前UI环境, *S_框架::g_3D视口环境, nullptr);
	}
	else if (name == L"边采样") {
		node = f_节点构建_多边形边采样节点(*g当前UI环境, *S_框架::g_3D视口环境, nullptr);
	}
	else if (name == L"顶点数据") {
		node = f_节点构建_几何数据(*g当前UI环境, *S_框架::g_3D视口环境, nullptr);
	}
	else if (name == L"面朝向") {
		node = f_节点构建_面朝向(*g当前UI环境, *S_框架::g_3D视口环境, nullptr);
	}
	else if (name == L"UV") {
		node = f_节点构建_几何UV数据(*g当前UI环境, *S_框架::g_3D视口环境, nullptr);
	}
	else if (name == L"光线数据") {
		node = f_节点构建_光线数据(*g当前UI环境, *S_框架::g_3D视口环境, nullptr);
	}
	else if (name == L"投影坐标") {
		node = f_节点构建_投影多边形纹理坐标(*g当前UI环境, *S_框架::g_3D视口环境, nullptr);
	}
	else if (name == L"复制多边形") {
		node = f_节点构建_多边形复制节点(*g当前UI环境, *S_框架::g_3D视口环境, nullptr);
	}
	else if (name == L"拷贝多边形") {
		node = f_节点构建_多边形拷贝节点(*g当前UI环境, *S_框架::g_3D视口环境, nullptr);
	}
	else if (name == L"变换多边形") {
		node = f_节点构建_多边形变换节点(*g当前UI环境, *S_框架::g_3D视口环境, nullptr);
	}
	else if (name == L"取多边形面顶点") {
		node = f_节点构建_取多边形面顶点节点(*g当前UI环境, *S_框架::g_3D视口环境, nullptr);
	}
	else if (name == L"设置多边形面顶点") {
		node = f_节点构建_设置多边形面顶点节点(*g当前UI环境, *S_框架::g_3D视口环境, nullptr);
	}
	else if (name == L"多边形转网格") {
		node = f_节点构建_多边形转网格节点(*g当前UI环境, *S_框架::g_3D视口环境, nullptr);
	}
	else if (name == L"取网格元素") {
		node = f_节点构建_取网格元素节点(*g当前UI环境, *S_框架::g_3D视口环境, nullptr);
	}
	else if (name == L"取网格元素顶点") {
		node = f_节点构建_取网格元素顶点节点(*g当前UI环境, *S_框架::g_3D视口环境, nullptr);
	}
	else if (name == L"设置网格元素顶点") {
		node = f_节点构建_设置网格元素顶点(*g当前UI环境, *S_框架::g_3D视口环境, nullptr);
	}
	else if (name == L"取多边形边") {
		node = f_节点构建_取多边形边节点(*g当前UI环境, *S_框架::g_3D视口环境, nullptr);
	}
	if (node) fun_节点视口回调(node, true);
}


void on_2级物体节点创建菜单项(C_Widget* self, const std::wstring name, uint16 id) {
	C_节点面板* node = nullptr;
	if (name == L"空物体") {
		node = f_节点构建_物体节点(*g当前UI环境, *S_框架::g_3D视口环境);
	} 
	else if (name == L"摄像机") {
		node = f_节点构建_摄像机节点(*g当前UI环境, *S_框架::g_3D视口环境);
	}
	else if (name == L"目标相机") {
		node = f_节点构建_目标摄像机节点(*g当前UI环境, *S_框架::g_3D视口环境);
	}
	else if (name == L"虚拟体") {
		node = f_节点构建_物体虚拟体节点(*g当前UI环境, *S_框架::g_3D视口环境);
	}
	else if (name == L"引用物体") {
		node = f_节点构建_引用物体节点(*g当前UI环境, *S_框架::g_3D视口环境);
	}
	else if (name == L"取物体") {
		node = f_节点构建_取物体节点(*g当前UI环境, *S_框架::g_3D视口环境);
	}
	else if (name == L"查找子物体") {
		node = f_节点构建_查找子物体节点(*g当前UI环境, *S_框架::g_3D视口环境);
	}
	else if (name == L"物体父子关系") {
		node = f_节点构建_物体父子关系节点(*g当前UI环境, *S_框架::g_3D视口环境);
	}
	else if (name == L"设置物体数据") {
		node = f_节点构建_设置物体数据节点(*g当前UI环境, *S_框架::g_3D视口环境);
	}
	else if (name == L"取物体属性") {
		node = f_节点构建_取物体属性节点(*g当前UI环境, *S_框架::g_3D视口环境);
	}
	else if (name == L"取物体变换") {
		node = f_节点构建_取物体变换节点(*g当前UI环境, *S_框架::g_3D视口环境);
	}
	else if (name == L"取物体矩阵") {
		node = f_节点构建_取物体矩阵节点(*g当前UI环境, *S_框架::g_3D视口环境);
	}
	else if (name == L"取物体材质") {
		node = f_节点构建_取物体材质节点(*g当前UI环境, *S_框架::g_3D视口环境);
	}
	else if (name == L"取光追材质") {
		node = f_节点构建_取物体光追材质节点(*g当前UI环境, *S_框架::g_3D视口环境);
	}
	else if (name == L"选择物体") {
		node = f_节点构建_选择物体节点(*g当前UI环境, *S_框架::g_3D视口环境);
	}
	else if (name == L"拷贝物体") {
		node = f_节点构建_物体拷贝节点(*g当前UI环境, *S_框架::g_3D视口环境);
	}
	else if (name == L"物体对称") {
		node = f_节点构建_对称物体节点(*g当前UI环境, *S_框架::g_3D视口环境);
	}
	else if (name == L"设置物体矩阵") {
		 node = f_节点构建_设置物体矩阵节点(*g当前UI环境, *S_框架::g_3D视口环境);
	}
	else if (name == L"设置物体变换") {
		node = f_节点构建_设置物体变换节点(*g当前UI环境, *S_框架::g_3D视口环境);
	}
	else if (name == L"设置摄像机") {
		node = f_节点构建_设置摄像机属性节点(*g当前UI环境, *S_框架::g_3D视口环境);
	}
	else if (name == L"物体绑定骨骼") {
		node = f_节点构建_物体绑定骨骼节点(*g当前UI环境, *S_框架::g_3D视口环境);
	}
	else if (name == L"加载物体") {
		node = f_节点构建_外部加载物体节点(*g当前UI环境, *S_框架::g_3D视口环境);
	}
	else if (name == L"骨架") {
		node = f_节点构建_骨骼节点(*g当前UI环境, *S_框架::g_3D视口环境);
	}
	else if (name == L"骨头") {
		node = f_节点构建_骨头节点(*g当前UI环境, *S_框架::g_3D视口环境);
	}
	else if (name == L"IK") {
		node = f_节点构建_骨骼IK节点(*g当前UI环境, *S_框架::g_3D视口环境);
	}
	else if (name == L"蒙皮") {
		node = f_节点构建_蒙皮节点(*g当前UI环境, *S_框架::g_3D视口环境);
	}

	if(node) fun_节点视口回调(node, true);
}


void f_on_场景2级节点创建菜单项(C_Widget* self, const std::wstring name, uint16 id) {
	C_节点面板* node = nullptr;
	if (name == L"场景") {
		//auto* node = f_节点构建_视频(*g当前UI环境);
	}
	else if (name == L"时间帧") {
		node = f_节点构建_帧时间(*g当前UI环境, *S_框架::g_3D视口环境);
	}
	else if (name == L"射线拾取") {
		node = f_节点构建_射线物体拾取(*g当前UI环境, *S_框架::g_3D视口环境);
	}
	else if (name == L"范围拾取") {
		node = f_节点构建_范围拾取(*g当前UI环境, *S_框架::g_3D视口环境);
	}
	else if (name == L"OpenVDB网格") {
		node = f_节点构建_OpenVDB网格(*g当前UI环境, *S_框架::g_3D视口环境);
	}
	else if (name == L"视口手柄") {
		node = f_节点构建_视口手柄(*g当前UI环境, *S_框架::g_3D视口环境);
	}
	if (node) fun_节点视口回调(node, true);
}


void f_on_材质2级节点创建菜单项(C_Widget* self, const std::wstring name, uint16 id) {
	C_节点面板* node = nullptr;
	if (name == L"材质") {
		node = f_节点构建_材质槽(*g当前UI环境, *S_框架::g_3D视口环境, nullptr);
	}
	else if (name == L"编辑材质") {
		node = f_节点构建_材质(*g当前UI环境, *S_框架::g_3D视口环境, nullptr);
	}
	else if (name == L"当前材质") {
		node = f_节点构建_当前材质(*g当前UI环境, *S_框架::g_3D视口环境, nullptr);
	}
	else if (name == L"材质组ID") {
		node = f_节点构建_几何ID(*g当前UI环境, *S_框架::g_3D视口环境, nullptr);
	}
	else if (name == L"自发光") {
		node = f_节点构建_自发光材质(*g当前UI环境, *S_框架::g_3D视口环境, nullptr);
	}
	else if (name == L"纹理") {
		node = f_节点构建_纹理(*g当前UI环境, *S_框架::g_3D视口环境, nullptr);
	}
	else if (name == L"噪波纹理") {
		node = f_节点构建_噪波纹理属性(*g当前UI环境, *S_框架::g_3D视口环境, nullptr);
	}
	else if (name == L"渐变纹理") {
		node = f_节点构建_渐变纹理(*g当前UI环境, *S_框架::g_3D视口环境, nullptr);
	}
	else if (name == L"棋盘格") {
		node = f_节点构建_棋盘格纹理(*g当前UI环境, *S_框架::g_3D视口环境, nullptr);
	}
	else if (name == L"外部纹理") {
		node = f_节点构建_外部纹理(*g当前UI环境, *S_框架::g_3D视口环境, nullptr);
	}
	else if (name == L"纹理集") {
		node = f_节点构建_外部纹理集(*g当前UI环境, *S_框架::g_3D视口环境, nullptr);
	}
	else if (name == L"纹理采样") {
		node = f_节点构建_2D纹理采样(*g当前UI环境, *S_框架::g_3D视口环境, nullptr);
	}
	else if (name == L"视频") {
		node = f_节点构建_视频(*g当前UI环境);
	}
	else if (name == L"设置材质") {
		node = f_节点构建_设置物体材质(*g当前UI环境, *S_框架::g_3D视口环境, nullptr);
	}
	else if (name == L"着色器") {
		node = f_节点构建_设置PBR材质属性(*g当前UI环境, *S_框架::g_3D视口环境, nullptr);
	}
	else if (name == L"基于物理计算") {
		node = f_节点构建_基于物理计算着色(*g当前UI环境, *S_框架::g_3D视口环境, nullptr);
	}
	
	if (node) fun_节点视口回调(node, true);
}

void f_on_计算2级节点创建菜单项(C_Widget* self, const std::wstring name, uint16 id) {
	C_节点面板* node = nullptr;
	if (name == L"计算") {
		node = f_节点构建_单值计算(*g当前UI环境, *S_框架::g_3D视口环境, nullptr);
	}
	else if (name == L"位运算") {
		node = f_节点构建_位运算(*g当前UI环境, *S_框架::g_3D视口环境, nullptr);
	}
	else if (name == L"逻辑计算") {
		node = f_节点构建_逻辑计算节点(*g当前UI环境, *S_框架::g_3D视口环境, nullptr);
	}
	else if (name == L"矢量计算") {
		node = f_节点构建_矢量计算(*g当前UI环境, *S_框架::g_3D视口环境, nullptr);
	}
	else if (name == L"单目计算") {
		node = f_节点构建_单目计算(*g当前UI环境, *S_框架::g_3D视口环境, nullptr);
	}
	else if (name == L"几何计算") {
		node = f_节点构建_几何计算(*g当前UI环境, *S_框架::g_3D视口环境, nullptr);
	}
	else if (name == L"两向量标量") {
		node = f_节点构建_两向量标量计算(*g当前UI环境, *S_框架::g_3D视口环境, nullptr);
	}
	else if (name == L"归一化") {
		node = f_节点构建_归一化计算(*g当前UI环境, *S_框架::g_3D视口环境, nullptr);
	}
	else if (name == L"长度") {
		node = f_节点构建_向量长度(*g当前UI环境, *S_框架::g_3D视口环境, nullptr);
	}
	else if (name == L"三角函数") {
		node = f_节点构建_三角函数计算(*g当前UI环境, *S_框架::g_3D视口环境, nullptr);
	}
	
	else if (name == L"合并XYZ") {
		node = f_节点构建_合并XYZ(*g当前UI环境, *S_框架::g_3D视口环境, nullptr);
	}
	else if (name == L"分离XYZ") {
		node = f_节点构建_分离XYZ(*g当前UI环境, *S_框架::g_3D视口环境, nullptr);
	}
	else if (name == L"混合") {
		node = f_节点构建_混合(*g当前UI环境, *S_框架::g_3D视口环境, nullptr);
	}
	else if (name == L"矢量分量") {
		node = f_节点构建_设置矢量分量(*g当前UI环境, *S_框架::g_3D视口环境, nullptr);
	}
	else if (name == L"矩阵变换") {
		node = f_节点构建_矩阵变换(*g当前UI环境, *S_框架::g_3D视口环境, nullptr);
	}
	else if (name == L"矩阵计算") {
		node = f_节点构建_矩阵计算(*g当前UI环境, *S_框架::g_3D视口环境, nullptr);
	}
	else if (name == L"矩阵转换") {
		node = f_节点构建_矩阵转换(*g当前UI环境, *S_框架::g_3D视口环境, nullptr);
	}

	else if (name == L"向量转四元数") {
		node = f_节点构建_向量转四元数(*g当前UI环境, *S_框架::g_3D视口环境, nullptr);
	}
	else if (name == L"四元数计算") {
		node = f_节点构建_四元数计算(*g当前UI环境, *S_框架::g_3D视口环境, nullptr);
	}
	else if (name == L"四元数变换") {
		node = f_节点构建_四元数变换(*g当前UI环境, *S_框架::g_3D视口环境, nullptr);
	}
	else if (name == L"向量角度组成四元数") {
		node = f_节点构建_向量角度组成四元数(*g当前UI环境, *S_框架::g_3D视口环境, nullptr);
	}
	else if (name == L"四元数转欧拉角") {
		node = f_节点构建_四元数转换为欧拉角(*g当前UI环境, *S_框架::g_3D视口环境, nullptr);
	}
	else if (name == L"四元数转矩阵") {
		node = f_节点构建_四元数转换为矩阵节点(*g当前UI环境, *S_框架::g_3D视口环境, nullptr);
	}
	else if (name == L"顶点矩阵变换") {
		node = f_节点构建_顶点变换(*g当前UI环境, *S_框架::g_3D视口环境, nullptr);
	}
	else if (name == L"点到平面") {
		node = f_节点构建_平面到点节点(*g当前UI环境, *S_框架::g_3D视口环境, nullptr);
	}
	else if (name == L"平面线段相交") {
		node = f_节点构建_平面线段相交节点(*g当前UI环境, *S_框架::g_3D视口环境, nullptr);
	}
	else if (name == L"旋转向量") {
		node = f_节点构建_旋转向量节点(*g当前UI环境, *S_框架::g_3D视口环境, nullptr);
	}
	else if (name == L"轴向旋转") {
		node = f_节点构建_轴向旋转向量节点(*g当前UI环境, *S_框架::g_3D视口环境, nullptr);
	}
	else if (name == L"绕点旋转") {
		node = f_节点构建_绕点旋转(*g当前UI环境, *S_框架::g_3D视口环境, nullptr);
	}
	else if (name == L"射线相交") {
		node = f_节点构建_射线相交(*g当前UI环境, *S_框架::g_3D视口环境, nullptr);
	}
	else if (name == L"赋值") {
		node = f_节点构建_回写节点(*g当前UI环境, *S_框架::g_3D视口环境, nullptr);
	}
	else if (name == L"圆坐标生成") {
		node = f_节点构建_圆坐标生成节点(*g当前UI环境, *S_框架::g_3D视口环境, nullptr);
	}
	else if (name == L"直线") {
		node = f_节点构建_直线(*g当前UI环境, *S_框架::g_3D视口环境, nullptr);
	}
	else if (name == L"渐变") {
		node = f_节点构建_渐变采样(*g当前UI环境, *S_框架::g_3D视口环境, nullptr);
	}
	else if (name == L"钳制") {
		node = f_节点构建_单值钳制(*g当前UI环境, *S_框架::g_3D视口环境, nullptr);
	}
	else if (name == L"矢量钳制") {
		node = f_节点构建_矢量钳制(*g当前UI环境, *S_框架::g_3D视口环境, nullptr);
	}
	else if (name == L"坐标转索引") {
		node = f_节点构建_坐标转索引节点(*g当前UI环境, *S_框架::g_3D视口环境, nullptr);
	}
	else if (name == L"索引转坐标") {
		node = f_节点构建_索引转坐标节点(*g当前UI环境, *S_框架::g_3D视口环境, nullptr);
	}
	else if (name == L"步进") {
		node = f_节点构建_步进计算节点(*g当前UI环境, *S_框架::g_3D视口环境, nullptr);
	}
	else if (name == L"索引数组排序") {
		node = f_节点构建_索引数组排序(*g当前UI环境, *S_框架::g_3D视口环境, nullptr);
	}
	else if (name == L"取空间邻接") {
		node = f_节点构建_取空间邻接数据(*g当前UI环境, *S_框架::g_3D视口环境, nullptr);
	}
	if (node) fun_节点视口回调(node, true);
}


void f_on_物理体2级节点创建菜单项(C_Widget* self, const std::wstring name, uint16 id) {
	C_节点面板* node = nullptr;
	if (name == L"粒子系统") {
		node = f_节点构建_粒子系统(*g当前UI环境, *S_框架::g_3D视口环境);
	} 
	else if (name == L"物理几何") {
		node = f_节点构建_物理几何体(*g当前UI环境, *S_框架::g_3D视口环境, nullptr);
	}
	else if (name == L"物理体") {
		node = f_节点构建_物理体(*g当前UI环境, *S_框架::g_3D视口环境);
	}
	else if (name == L"物理引擎") {
		node = f_节点构建_物理引擎(*g当前UI环境, *S_框架::g_3D视口环境, nullptr);
	} 
	else if (name == L"解算") {
		node = f_节点构建_解算器模拟(*g当前UI环境, *S_框架::g_3D视口环境);
	}
	
	else if (name == L"取物理体") {
		node = f_节点构建_取物理体节点(*g当前UI环境, *S_框架::g_3D视口环境, nullptr);
	} 
	else if (name == L"绑定物体") {
		node = f_节点构建_物理体绑定物体节点(*g当前UI环境, *S_框架::g_3D视口环境, nullptr);
	}
	else if (name == L"应用力") {
		node = f_节点构建_物理应用力(*g当前UI环境, *S_框架::g_3D视口环境, nullptr);
	}
	else if (name == L"更新肌腱") {
		node = f_节点构建_更新肌腱力度(*g当前UI环境, *S_框架::g_3D视口环境, nullptr);
	}
	else if (name == L"发射") {
		node = f_节点构建_发射(*g当前UI环境, *S_框架::g_3D视口环境);
	}
	else if (name == L"FleX参数") {
		node = f_节点构建_FleX参数(*g当前UI环境, *S_框架::g_3D视口环境);
	}
	else if (name == L"PBF解算器") {
		node = f_节点构建_PBF解算器(*g当前UI环境, *S_框架::g_3D视口环境);
	}
	else if (name == L"FLIP解算器") {
		node = f_节点构建_FLIP解算器(*g当前UI环境);
	}
	

	if (node) fun_节点视口回调(node, true);
}



void f_on_网络2级节点创建菜单项(C_Widget* self, const std::wstring name, uint16 id) {
	C_节点面板* node = nullptr;
	if (name == L"UDP接收图像") {
		node = f_节点构建_接收UDP图像(*g当前UI环境);
	}
	if (node) fun_节点视口回调(node, true);
}



void f_on_动画2级节点创建菜单项(C_Widget* self, const std::wstring name, uint16 id) {
	C_节点面板* node = nullptr;
	if (name == L"非线性轨道") {
		node = f_节点构建_非编轨道(*g当前UI环境, S_框架::g_3D视口环境);
	}
	if (node) fun_节点视口回调(node, true);
}



void f_on_2级节点创建脚本(C_Widget* self, const std::wstring name, uint16 id) {
	C_节点面板* node = nullptr;
	if (name == L"函数") {
		node = f_节点构建_函数(*g当前UI环境, *S_框架::g_3D视口环境, nullptr, nullptr);
	}
	else if (name == L"程序集") {
		
	}
	else if (name == L"Python") {
		node = f_节点构建_Python(*g当前UI环境, *S_框架::g_3D视口环境, nullptr);
	}
	if (node) fun_节点视口回调(node, true);
}



void f_on_调试2级节点创建菜单项(C_Widget* self, const std::wstring name, uint16 id) {
	C_节点面板* node = nullptr;
	if (name == L"几何预览") {
		node = f_节点构建_几何预览(*g当前UI环境, *S_框架::g_3D视口环境, nullptr);
	}
	else if (name == L"调试输出") {
		node = f_节点构建_调试输出(*g当前UI环境, *S_框架::g_3D视口环境, nullptr);
	}
	else if (name == L"控制台输出") {
		node = f_节点构建_控制台输出节点(*g当前UI环境, *S_框架::g_3D视口环境, nullptr);
	}
	if (node) fun_节点视口回调(node, true);
}





static S_菜单创建参数 f_物体子菜单创建() {
	S_菜单创建参数 创建参数 = {
		f_on_物理体2级节点创建菜单项, {

			{L"点粒子发射体", "", 0},
			{L"线粒子发射体", "", 0},
			{L"平面粒子发射体", "", 0},
			{L"方体粒子发射体", "", 0},
			{L"网格粒子发射体", "", 0},
			//{L"网格粒子发射体", "", 0},
		}
	};


	return 创建参数;
}


static S_菜单创建参数 物体创建参数 = {
	on_2级物体节点创建菜单项, {

		{L"空物体", "", 0},
		{L"取物体", "zoom", 0},
		{L"查找子物体", "zoom", 0},
		{L"引用物体", "链接", 0},
		{L"摄像机", "摄像机", 0},
		{L"目标相机", "目标相机", 0},
		{L"虚拟体", "", 0},
		{L"加载物体", "打开文件夹", 0},

	{L"", "", 0},
		{L"物体父子关系", "", 0},
		{L"设置物体数据", "", 0},

	{L"", "", 0},
		{L"取物体变换", "", 0},
		{L"取物体矩阵", "", 0},
		{L"设置物体矩阵", "", 0},
		{L"设置物体变换", "", 0},
		{L"设置摄像机", "", 0},

	{L"", "", 0},
		{L"取物体材质", "", 0},
		{L"取光追材质", "", 0},
		
		{L"选择物体", "选择", 0},
		{L"拷贝物体", "clipboard_copy", 0},
		{L"物体对称", "", 0},
		{L"取物体属性", "", 0},

	{L"", "", 0},
		{L"物体绑定骨骼", "", 0},
		//{L"记录点节点", "", 0},
		{L"骨架", "", 0},
		{L"骨头", "", 0},
		//{L"IK", "", 0},
		{L"蒙皮", "", 0},
	}
};

static S_菜单创建参数 g可编译_物体创建参数 = {
		on_2级物体节点创建菜单项, {
			{L"空物体", "", 0},
			{L"取物体", "zoom", 0},
			{L"引用物体", "链接", 0},
			{L"摄像机", "摄像机", 0},
		}
};

static S_菜单创建参数 g基本几何体创建参数 = {
	on_2级几何节点创建菜单项, {
		{L"网格", "三角网格", 0},
		{L"平面", "矩形线框", 0},
		{L"球体", "圆形线框", 0},
		//{L"圆环", "", 0},
		{L"方体", "立体线框", 0},
		//{L"圆柱", "", 0},
		//{L"圆锥", "", 0},
		//{L"六面", "", 0},
		{L"线框立方体", "四边顶点", 0},
		{L"几何", "几何", 0},
	}
};

static S_菜单创建参数 g可编译_多边形节点创建参数 = {
	on_2创建多边形节点菜单项, {
		{L"网格", "三角网格", 0},
		{L"几何ID", "指示ID", 0},
		{L"当前多边形", "", 0},
		{L"基本多边形", "矩形线框", 0},
		
		{L"+顶点", "", 0},
	//{L"-顶点", ", 0"},
		{L"+UV", "", 0},
	//{L"-UV", ", 0"},
		{L"+元素", "四边顶点", 0},

		{L"边", "直线顶点", 0},
		{L"面", "四边顶点", 0},
		
	{L"", "", 0},
		{L"取索引", "", 0},
		{L"取面属性", "", 0},
		{L"取多边形元素", "", 0},
	{L"", "", 0},
		{L"设置面属性", "", 0},
		{L"设置面UV", "", 0},
		{L"设置材质槽ID", "材质ID", 0},
	}
};

static S_菜单创建参数 g可编译_函数_几何网格节点创建参数 = {
	on_2创建多边形节点菜单项, {
		{L"网格", "三角网格", 0},
		{L"基本多边形", "矩形线框", 0},

		{L"+顶点", "", 0},
	//{L"-顶点", ", 0"},
		{L"+UV", "", 0},
	//{L"-UV", ", 0"},
		{L"+元素", "四边顶点", 0},

		{L"边", "直线顶点", 0},
		{L"面", "四边顶点", 0},

	{L"", "", 0},
		{L"取索引", "", 0},
		{L"取面属性", "", 0},
		{L"取多边形元素", "", 0},
	{L"", "", 0},
		{L"设置面属性", "", 0},
		{L"设置面UV", "", 0},
		{L"设置材质槽ID", "材质ID", 0},
	}
};

static S_菜单创建参数 g网格参数 = {
	f_on_网格2级节点创建菜单项, {
		{L"边采样", "", 0},

	{L"", "", 0},
		{L"网格", "", 0},
		{L"面朝向", "", 0},
		{L"设置材质", "", 0},
		{L"从网格构建体素", "", 0},
		{L"网格采样", "", 0},
		{L"计算法线", "", 0},
		{L"截取网格", "", 0},
		{L"网格属性", "", 0},
		{L"填充顶点", "", 0},
		{L"填充纹理坐标", "", 0},
		{L"填充索引", "", 0},

	{L"", "", 0},
		{L"多边形桥接", "", 0},
		{L"多边形转网格", "", 0},
		{L"取网格元素", "", 0},
		{L"取网格元素顶点", "", 0},
		{L"设置网格元素顶点", "", 0},

	{L"", "", 0},
		{L"取多边形边", "", 0},
	}
};

static S_菜单创建参数 g可编译_网格参数 = {
	f_on_网格2级节点创建菜单项, {
		{L"边采样", "", 0},
		{L"多边形桥接", "", 0},
		{L"点桥接", "", 0},
		{L"边实体化", "", 0},
		{L"变换多边形", "移动", 0},

	{L"", "", 0},
		{L"复制多边形", "clipboard_copy", 0},
		{L"拷贝多边形", "拷贝文件", 0},
		
		{L"投影坐标", "", 0},
	{L"", "", 0},
		{L"取多边形面顶点", "", 0},
		{L"设置多边形面顶点", "", 0},

	{L"", "", 0},
		//{L"取网格元素", "", 0},
		{L"取网格元素顶点", "", 0},
		{L"设置网格元素顶点", "", 0},

	{L"", "", 0},
		{L"取多边形边", "", 0},
	}
};

S_菜单创建参数 g可编译_场景创建参数 = {
	f_on_场景2级节点创建菜单项, {
		//{L"场景", "font-448", 0},
		{L"时间帧", "font-448", 0},
		//{L"射线拾取", "font-257", 0},
		//{L"范围拾取", "font-257", 0},
		//{L"OpenVDB网格", "font-257", 0},
		//{L"视口手柄", "font-257", 0},
	}
};

static S_菜单创建参数 g可编译_材质几何数据 = {
	f_on_网格2级节点创建菜单项, {

		{L"顶点数据", "", 0},
		{L"UV", "", 0},
		{L"光线数据", "", 0},
		{L"投影坐标", "", 0},
	//{L"计算法线", "", 0},
	//{L"截取网格", "", 0},
	//{L"网格属性", "", 0},
	}
};


static S_菜单创建参数 g变量创建参数 = {
	f_on_变量2级节点创建菜单项, {
		{L"浮点变量", "", 0},
		{L"整数变量", "", 0},
		{L"I8变量", "", 0},
		{L"线段变量", "", 0},

	{L"", "", 0},
		{L"vec3", "", 0},
		{L"vec2", "", 0},
		{L"ivec3", "", 0},
		{L"矩阵", "", 0},

	{L"", "", 0},
		{L"[I8]", "", 0},
		{L"[I32]", "", 0},
		{L"[F32]", "", 0},

	{L"", "", 0},
		{L"[vec2]", "", 0},
		{L"[vec3]", "", 0},
		{L"[ivec2]", "", 0},
		{L"[ivec3]", "", 0},
		{L"[VecSphere]", "", 0},
		{L"[平面]", "", 0},

	{L"", "", 0},
		{L"[构建矩阵]", "", 0},
		{L"观察矩阵", "", 0},
		{L"[线段]", "", 0},

	{L"", "", 0},
		{L"合并元素", "", 0},
		{L"添加元素", "", 0},
		{L"插入元素", "", 0},
		{L"删除元素", "", 0},
		
		{L"复制数组", "", 0},
		{L"取元素", "", 0},

		{L"转换", "", 0},
		{L"取成员", "", 0},
		{L"坐标取数据", "", 0},

	{L"", "", 0},
		{L"取空间邻接", "", 0},
	}
};

static S_菜单创建参数 g变量创建参数_可编译 = {
	f_on_变量2级节点创建菜单项, {
		{L"引用", "", 0},
		{L"浮点变量", "", 0},
		{L"整数变量", "", 0},
		{L"无符号整数", "", 0},
		{L"I8变量", "", 0},

		{L"vec3", "", 0},
		{L"vec2", "", 0},
		{L"ivec3", "", 0},

	{L"", "", 0},
		{L"[I8]", "", 0},
		{L"[F32]", "", 0},
		{L"[I32]", "", 0},
		{L"[UI32]", "", 0},
		
	{L"", "", 0},
		{L"[vec2]", "", 0},
		{L"[vec3]", "", 0},
		{L"[vec4]", "", 0},
		{L"[ivec2]", "", 0},
		{L"[ivec3]", "", 0},
		{L"[平面]", "", 0},

	{L"", "", 0},
		{L"[多边形成员]", "", 0},

	{L"", "", 0},
		{L"矩阵", "", 0},
		{L"[构建矩阵]", "", 0},
		{L"观察矩阵", "", 0},

	{L"", "", 0},
		{L"合并元素", "", 0},
		{L"数组", "", 0},
		{L"添加元素", "", 0},
		{L"删除元素", "", 0},
		{L"数组属性", "", 0},
		{L"取元素", "", 0},
		{L"取头尾元素", "", 0},
		{L"查找元素", "放大镜", 0},
		{L"合并数组", "", 0},
		{L"复制数组", "clipboard_copy", 0},
		{L"数组重排", "重排", 0},
		{L"数组元素统计", "", 0},

		{L"取内存邻接", "", 0},
		
		{L"插入数组", "", 0},
		{L"数组打乱", "", 0},
		{L"数组抽取", "", 0},

	{L"", "", 0},
		{L"取空间邻接", "", 0},
	}
};

static S_菜单创建参数 g变量创建参数_着色器 = {
	f_on_变量2级节点创建菜单项, {
		{L"浮点变量", "", 0},
		{L"整数变量", "", 0},

	{L"", "", 0},
		{L"vec3", "", 0},
		{L"vec2", "", 0},
		{L"ivec3", "", 0},

	{L"", "", 0},
		{L"[vec2]", "", 0},
		{L"[vec3]", "", 0},
		{L"[vec4]", "", 0},
		{L"[平面]", "", 0},
	{L"", "", 0},
		{L"矩阵", "", 0},
		{L"[构建矩阵]", "", 0},
		//{L"观察矩阵", "", 0},

		{L"", "", 0},

		{L"数组", "", 0},
		{L"添加元素", "", 0},
		{L"数组属性", "", 0},
		{L"取元素", "", 0},
		{L"合并数组", "", 0},

		{L"取内存邻接", "", 0},
		{L"取空间邻接", "", 0},
		{L"插入数组", "", 0},
	}
};

static S_菜单创建参数 g计算创建参数 = {
	f_on_计算2级节点创建菜单项, {

		{L"计算", "", 0},
		{L"单目计算", "", 0},
		{L"混合", "", 0},

	{L"", "", 0},
		{L"矢量计算", "", 0},
		{L"几何计算", "", 0},
		{L"三角函数", "", 0},
		{L"合并XYZ", "", 0},
		{L"分离XYZ", "", 0},

		
		{L"两向量标量", "", 0},
		{L"归一化", "", 0},
		
		{L"旋转向量", "", 0},
		{L"轴向旋转向量", "", 0},
		{L"点到平面", "平面法线", 0},

	{L"向量转四元数", "", 0},
		{L"射线相交", "", 0},

	{L"", "", 0},
		{L"矩阵变换", "", 0},
		{L"矩阵计算", "", 0},
		{L"矩阵转换", "", 0},

	{L"", "", 0},
		{L"四元数计算", "", 0},
		{L"四元数变换", "", 0},
		{L"向量角度组成四元数", "", 0},
		{L"四元数转欧拉角", "", 0},
		{L"四元数转矩阵", "", 0},

	{L"", "", 0},
		{L"顶点矩阵变换", "", 0},
		{L"回写", "", 0},
		
	{L"", "", 0},
		{L"圆坐标生成", "圆形", 0},
		{L"直线", "直线", 0},
		{L"渐变", "曲线编辑", 0},

	{L"", "", 0},
		//{L"坐标转索引", "", 0},
		//{L"索引转坐标", "", 0},
		{L"步进", "", 0},
	}
};

static S_菜单创建参数 g计算创建参数_可编译 = {
	f_on_计算2级节点创建菜单项, {

		{L"计算", "", 0},
		{L"逻辑计算", "", 0},
		{L"单目计算", "", 0},
		{L"位运算", "", 0},
		{L"混合", "", 0},

	{L"", "", 0},
		{L"矢量计算", "", 0},
		{L"两向量标量", "", 0},
		{L"归一化", "", 0},
		{L"长度", "", 0},
		{L"三角函数", "", 0},
		{L"旋转向量", "", 0},
		{L"轴向旋转", "", 0},
		{L"绕点旋转", "", 0},
		{L"点到平面",     "平面法线", 0},
		{L"平面线段相交", "线平面相交", 0},
	{L"", "", 0},
		{L"合并XYZ", "", 0},
		{L"分离XYZ", "", 0},
		{L"矢量分量", "", 0},

	{L"", "", 0},
		{L"矩阵变换", "", 0},
		{L"矩阵计算", "", 0},
		{L"顶点矩阵变换", "", 0},
	{L"", "", 0},
		{L"向量转四元数", "", 0},
		{L"向量角度组成四元数", "", 0},
		{L"四元数计算", "", 0},
		{L"四元数变换", "", 0},
		{L"四元数转欧拉角", "", 0},
		{L"四元数转矩阵", "", 0},
	{L"", "", 0},
		{L"赋值", "", 0},
		{L"钳制", "", 0},
		{L"矢量钳制", "", 0},
	{L"", "", 0},
		{L"圆坐标生成", "圆形", 0},
		{L"直线", "直线", 0},
		{L"渐变", "曲线编辑", 0},

	{L"", "", 0},
		{L"坐标转索引", "", 0},
		{L"索引转坐标", "", 0},
		{L"步进", "", 0},
		{L"索引数组排序", "重排", 0},
		{L"取空间邻接", "", 0},
	}
};


static S_菜单创建参数 g逻辑创建参数 = {
	f_on_逻辑2级节点创建菜单项, {

		{L"手动执行", "", 0},

		{L"if_else", "", 0},
		{L"for", "循环", 0},
		{L"跳过", "", 0},
		{L"函数", "", 0},
	}
};

static S_菜单创建参数 g可编译_逻辑创建参数 = {
	f_on_逻辑2级节点创建菜单项, {
		{L"判断", "", 0},
		{L"loop", "循环", 0},
		{L"迭代", "迭代", 0},
		//{L"for", "", 0},
		{L"跳过", "返回", 0},
		{L"函数", "", 0},
		{L"End", "", 0},
	}
};

static S_菜单创建参数 g材质创建参数 = {
	f_on_材质2级节点创建菜单项, {
		{L"材质", "", 0},
		{L"编辑材质", "球", 0},
		//{L"PBR", "", 0},
	{L"", "", 0},
		{L"外部纹理", "font-451", 0},
		{L"纹理集", "font-451", 0},
		//{L"纹理", "", 0},
		{L"噪波纹理", "", 0},
	{L"", "", 0},
		{L"设置材质", "", 0},
		
	}
};

static S_菜单创建参数 g可编译_材质创建参数 = {
	f_on_材质2级节点创建菜单项, {
		//{L"着色器", "", 0},
		{L"当前材质", "球", 0},
		{L"材质组ID", "指示ID", 0},

	{L"", "", 0},
		{L"着色器", "", 0},

	{L"", "", 0},
		{L"外部纹理", "font-451", 0},
		{L"纹理", "", 0},
		{L"过程纹理", "", 0},
		//{L"设置材质", "", 0},
	}
};

static S_菜单创建参数 g可编译_着色器创建参数 = {
	f_on_材质2级节点创建菜单项, {
		{L"基于物理计算", "", 0},
		{L"自发光", "", 0},
	}
};

static S_菜单创建参数 g可编译_着色器纹理创建参数 = {
	f_on_材质2级节点创建菜单项, {
		{L"外部纹理", "", 0},
		{L"纹理", "", 0},
		{L"噪波纹理", "", 0},
		{L"渐变纹理", "", 0},
		{L"棋盘格", "", 0},
		{L"纹理采样", "", 0},
	}
};


static S_菜单创建参数 g调试创建参数 = {
	f_on_调试2级节点创建菜单项, {
		{L"调试输出", "", 0},
		{L"几何预览", "几何", 0},
	}
};

static S_菜单创建参数 g调试创建参数_可编译 = {
	f_on_调试2级节点创建菜单项, {
		{L"控制台输出", "app_window_shell", 0},
	}
};




C_Widget* f_init物体节点创建菜单(S_UI创建环境& ctx) {
	S_菜单创建参数 菜单创建参数;

	g当前UI环境 = &ctx;
	

	S_菜单创建参数 容器创建参数 = {
		f_on_2级容器节点创建菜单项, {
			{L"点距八叉树", "二叉树", 0},
			{L"包", "包", 0},
			{L"缓存写入", "", 0},
			{L"缓存读取", "", 0},
			{L"物体缓存", "", 0},
		{L"", "", 0},
			{L"写网格缓存", "存入", 0},
			{L"读网格缓存", "取出", 0},
		}
	};

	


	S_菜单创建参数 场景创建参数 = {
		f_on_场景2级节点创建菜单项, {

			{L"场景", "font-448", 0},
			{L"时间帧", "font-448", 0},
			{L"射线拾取", "font-257", 0},
			{L"范围拾取", "font-257", 0},
		{L"OpenVDB网格", "font-257", 0},
		{L"视口手柄", "font-257", 0},

		}
	};


	

	S_菜单创建参数 物理创建参数 = {
		f_on_物理体2级节点创建菜单项, {
			{L"物理几何", "", 0},
			{L"物理体", "", 0},
			{L"物理引擎", "", 0},
			{L"PBF解算器", "", 0},
			{L"FleX参数", "", 0},
			
		{L"取物理体", ", 0"},
		{L"绑定物体", ", 0"},
		{L"应用力", ", 0"},
			{L"解算", "", 0},
		{L"更新肌腱", "", 0},
			{L"粒子系统",		"", 0},
			{L"线粒子发射体",	"", 0},
			{L"发射", "", 0},
			{L"单方向力", "", 0},
		}
	};

	S_菜单创建参数 网络创建参数 = {
		f_on_网络2级节点创建菜单项, {

			{L"UDP接收图像", "", 0},

		}
	};

	S_菜单创建参数 动画创建参数 = {
		f_on_动画2级节点创建菜单项, {

			{L"非线性轨道", "", 0},

		}
	};

	S_菜单创建参数 设备创建参数 = {
		f_on_1级节点创建菜单项, {

			{L"XBOX控制器", "", 0},
			//{L"Kinect", "", 0},
			//{L"点光", "", 0},
		}
	};

	S_菜单创建参数 脚本创建参数 = {
		f_on_2级节点创建脚本, {
			{L"程序集", "", 0},
			{L"Python", "", 0},
		}
	};

	

	auto 灯光项 = f_menu参数_灯光();

	菜单创建参数 = {
		f_on_1级节点创建菜单项, {
			{L"几何", "三角网格", &g基本几何体创建参数},
			
			{L"物体", "font-123", &物体创建参数},
			{L"网格", "三角顶点", &g网格参数},
			{L"灯光", "光", &灯光项},
			{L"场景", "font-448", &场景创建参数},

			{L"材质", "sphere", &g材质创建参数},
			{L"变量", "font-355", &g变量创建参数},
			{L"容器", "二叉树", &容器创建参数},
			{L"计算", "mathematics5", &g计算创建参数},
			{L"逻辑", "font-409", &g逻辑创建参数},
			
			
			//{L"物理", "orbital", &物理创建参数},
			//{L"文件", "pack_file", 0},
			
			//{L"合成", "layers_1", 0},
			//{L"网络", "network30", &网络创建参数},
			//{L"动画", "movie", &动画创建参数},
			{L"设备", "设备", &设备创建参数},
			//{L"脚本", "network30", &脚本创建参数},
			{L"调试", "info", &g调试创建参数},
			{L"转接", "转接", 0},
			{L"框", "框", 0},
		}
	};

	auto* menu = f_ui_创建菜单(e_纵向, 菜单创建参数, ctx);

	return menu;
}

C_Widget* f_init多边形节点创建菜单(S_UI创建环境& ctx) {

	S_菜单创建参数 菜单创建参数 = {
		f_on_1级节点创建菜单项, {
			{L"几何", "三角网格", &g可编译_多边形节点创建参数},
			{L"网格", "三角顶点", &g可编译_网格参数},

			
			{L"变量", "font-355", &g变量创建参数_可编译},
			//{L"容器", "二叉树", &容器创建参数},
			{L"计算", "mathematics5", &g计算创建参数_可编译},
			{L"逻辑", "font-409", &g可编译_逻辑创建参数},
			{L"材质", "sphere", &g材质创建参数},
			{L"纹理", "图像", &g可编译_着色器纹理创建参数},

			{L"文件", "pack_file", 0},
			{L"场景", "font-448", &g可编译_场景创建参数},
			//{L"网络", "network30", &网络创建参数},
			//{L"动画", "movie", &动画创建参数},
			//{L"脚本", "network30", &脚本创建参数},
			{L"调试", "info", &g调试创建参数_可编译},
			{L"转接", "转接", 0},
			{L"框", "框", 0},
		}
	};

	auto* menu = f_ui_创建菜单(e_纵向, 菜单创建参数, ctx);
	return menu;
}

C_Widget* f_init材质节点创建菜单(S_UI创建环境& ctx) {
	S_菜单创建参数 菜单创建参数 = {
		f_on_1级节点创建菜单项, {
			{L"变量", "font-355", &g变量创建参数_可编译},
			{L"计算", "mathematics5", &g计算创建参数_可编译},
			{L"逻辑", "font-409", &g可编译_逻辑创建参数},
			{L"着色", "sphere", &g可编译_材质创建参数},
			{L"纹理", "图像", &g可编译_着色器纹理创建参数},

			{L"调试", "info", &g调试创建参数_可编译},
			{L"转接", "转接", 0},
			{L"框", "框", 0},
		}
	};

	auto* menu = f_ui_创建菜单(e_纵向, 菜单创建参数, ctx);
	return menu;
}

C_Widget* f_init着色器节点创建菜单(S_UI创建环境& ctx) {
	S_菜单创建参数 菜单创建参数 = {
		f_on_1级节点创建菜单项, {
			{L"几何", "三角顶点", &g可编译_材质几何数据},
			{L"变量", "font-355", &g变量创建参数_着色器},
			{L"计算", "mathematics5", &g计算创建参数_可编译},
			{L"逻辑", "font-409", &g可编译_逻辑创建参数},
			{L"着色", "font-409", &g可编译_着色器创建参数},
			{L"纹理", "font-409", &g可编译_着色器纹理创建参数},
			{L"转接", "转接", 0},
			{L"框", "框", 0},
		}
	};

	auto* menu = f_ui_创建菜单(e_纵向, 菜单创建参数, ctx);
	return menu;
}

C_Widget* f_init函数节点创建菜单(S_UI创建环境& ctx) {
	S_菜单创建参数 菜单创建参数 = {
		f_on_1级节点创建菜单项, {
			{L"物体", "", &g可编译_物体创建参数},
			{L"几何", "三角网格", &g可编译_函数_几何网格节点创建参数},
			{L"网格", "三角顶点", &g可编译_网格参数},

			{L"变量", "font-355", &g变量创建参数_可编译},
			{L"计算", "mathematics5", &g计算创建参数_可编译},
			{L"逻辑", "font-409", &g可编译_逻辑创建参数},
			{L"材质", "sphere", &g材质创建参数},
			{L"纹理", "图像", &g可编译_着色器纹理创建参数},

			{L"文件", "pack_file", 0},

			{L"调试", "info", &g调试创建参数_可编译},
			{L"转接", "转接", 0},
			{L"框", "框", 0},
		}
	};

	auto* menu = f_ui_创建菜单(e_纵向, 菜单创建参数, ctx);
	return menu;
}





/*C_Widget* f_init节点删除菜单(S_UI创建环境& ctx, fp_on_菜单项点击 fun) {
	S_菜单创建参数 创建参数 = {
		fun, {
			{L"删除", "", 0},
		}
	};

	auto* menu = f_ui_创建菜单(e_纵向, 创建参数, ctx);
	return menu;
}*/



void f_节点菜单_绑定视口回调(fp_节点创建视口回调 fun) {
	
}






C_节点面板* f_节点构建_重构(C_节点面板* plane, C_节点基类* node) {
	if (!plane) {
		auto it = C_节点面板::g节点面板构建函数.find(node->m_TypeName);
		if (it != C_节点面板::g节点面板构建函数.end()) {
			plane = (it->second)(*g当前UI环境, *S_框架::g_3D视口环境, node, nullptr);
		}
	}
	else {
		auto it = C_节点面板::g节点面板重置函数.find(node->m_TypeName);
		if (it != C_节点面板::g节点面板重置函数.end()) {
			(it->second)(plane, node);
		}
	}

	if (plane) return plane;


	//=========================== 废弃!!!!!!!!! 容器节点重构 ===============================
	if (node->m_TypeName == "点距八叉树节点") {
		if (!plane) plane = f_节点构建_点距八叉树(*g当前UI环境, *S_框架::g_3D视口环境, node);
		f_节点重置_点距八叉树(plane, node);
	}


	if (node->m_TypeName == "UDP接收图像节点") {
		if (!plane) plane = f_节点构建_接收UDP图像(*g当前UI环境, node);
		f_节点重置_接收UDP图像(plane, node);

	}else if (node->m_TypeName == "流视频节点") {
		if (!plane) plane = f_节点构建_视频(*g当前UI环境, node);
		f_节点重置_视频(plane, node);

	} else if (node->m_TypeName == "手动执行节点") {
		if (!plane) plane = f_节点构建_手动执行(*g当前UI环境, node);
		f_节点重置_手动执行(plane, node);

	} else if (node->m_TypeName == "物体节点") {
		if (!plane) plane = f_节点构建_物体节点(*g当前UI环境, *S_框架::g_3D视口环境, node);
		f_节点重置_物体节点(plane, node);

	} 
	else if (node->m_TypeName == "几何预览节点") {
		if (!plane) plane = f_节点构建_几何预览(*g当前UI环境, *S_框架::g_3D视口环境, node);
		f_节点重置_几何预览(plane, node);
	}

	

	//=========================== 动画节点重构 ===============================
	else if (node->m_TypeName == "动画轨道节点") {
		if (!plane) plane = f_节点构建_非编轨道(*g当前UI环境, S_框架::g_3D视口环境);
		f_节点重置_非编轨道(plane, node);

	}
	

	bool 是否有创建 = false;

	是否有创建 = f_场景节点重构(&plane, node, g当前UI环境);

	if (!是否有创建) {
		是否有创建 = f_物体节点重构(&plane, node, g当前UI环境);
	}

	if (!是否有创建) {
		是否有创建 = f_计算节点重构(&plane, node, g当前UI环境);
	}

	if (!是否有创建) {
		是否有创建 = f_几何网格节点重构(&plane, node, g当前UI环境);
	}

	if (!是否有创建) {
		是否有创建 = f_物理节点重构(&plane, node, g当前UI环境);
	}

	if (!是否有创建) {
		是否有创建 = f_脚本节点重构(&plane, node, g当前UI环境);
	}


	if (!是否有创建) {
		是否有创建 = f_逻辑节点重构(&plane, node, g当前UI环境);
	}

	return plane;
}

C_节点面板* f_节点构建_从节点构建节点(C_节点基类* node, bool 是否关联, bool 创建新节点) {
	C_节点树* tree = nullptr;
	if (是否关联) {
		switch (node->m_Type) {
		case E_节点类型::e_节点Type_几何: {
			break;
		}
		case E_节点类型::e_节点Type_函数: {
			tree = ((C_函数节点*)node)->f_get子集树();
			break;
		}
		}
	}

	C_节点面板* newNode = nullptr;
	if (创建新节点) {
		newNode = C_节点面板::g节点面板构建函数[node->m_TypeName](*g当前UI环境, *S_框架::g_3D视口环境, nullptr, tree);
	}
	else {
		newNode = C_节点面板::g节点面板构建函数[node->m_TypeName](*g当前UI环境, *S_框架::g_3D视口环境, node, tree);
	}
	
	
	//关联节点面板
	if (tree) {
		for (auto& nodePanel : node->m_包含在多个视口的UI部件) {
			newNode->m_同子集节点树关联UI部件 = ((C_节点面板*)nodePanel)->m_同子集节点树关联UI部件;
		}
		(*newNode->m_同子集节点树关联UI部件).insert(newNode);
	}

	newNode->f_setOriginalPos(node->m_坐标);
	


	//拷贝插座
	uint32 num = node->f_get输入插座Num();
	for (uint32 i = 0; i < num; ++i) {
		auto* socket = node->f_get输入插座(i);

		if (i >= newNode->m_NodeData->f_get输入插座Num()) {
			auto* new_socket = f_su_创建节点后端插座(socket->m_identifier, socket->m_Type);
			newNode->m_NodeData->f_add插座(new_socket, E_插座方向::e_插座Type_输入, i);
			newNode->f_addInSocket(new_socket, i);
		}
		else {
			newNode->m_NodeData->f_get输入插座(i);
			f_su_切换后端插座类型(newNode->m_NodeData, E_插座方向::e_插座Type_输入, i, socket->m_Type);
		}
	}

	num = node->f_get输出插座Num();
	for (uint32 i = 0; i < num; ++i) {
		auto* socket = node->f_get输出插座(i);

		if (i >= newNode->m_NodeData->f_get输出插座Num()) {
			auto* new_socket = f_su_创建节点后端插座(socket->m_identifier, socket->m_Type);
			newNode->m_NodeData->f_add插座(new_socket, E_插座方向::e_插座Type_输出, i);
			newNode->f_addOutSocket(new_socket, i);
		}
		else {
			newNode->m_NodeData->f_get输出插座(i);
			f_su_切换后端插座类型(newNode->m_NodeData, E_插座方向::e_插座Type_输出, i, socket->m_Type);
		}
	}

	return newNode;
}

C_节点面板* f_节点构建_从节点构建节点面板(C_节点基类* plane, bool 是否关联)
{
	return nullptr;
}

C_节点面板* f_节点构建_用名称构建节点面板(const std::string& 节点类型名称) {
	C_节点面板* plane = nullptr;
	auto it = C_节点面板::g节点面板构建函数.find(节点类型名称);
	if (it != C_节点面板::g节点面板构建函数.end()) {
		plane = (it->second)(*g当前UI环境, *S_框架::g_3D视口环境, nullptr, nullptr);
	}
	return plane;
}


void f_NodeView_深拷贝节点(std::vector<C_节点基类*>& 节点面板, C_节点树* 节点视口) {
	


}






